# 0001, 2022-04-28 08:05:01, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
# for i in range(v.shape[0]):
# if v[i] != i: return False
# return True
s = np.arange(v.shape[0])
return v != s
| # 0002, 2022-04-28 08:05:16, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
# for i in range(v.shape[0]):
# if v[i] != i: return False
# return True
s = np.arange(v.shape[0]+1)
return v != s
| # 0003, 2022-04-28 08:06:39, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
# for i in range(v.shape[0]):
# if v[i] != i: return False
# return True
s = np.arange(v.shape[0])
if v[s] != s: return False
return True
| # 0004, 2022-04-28 08:07:14, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
# for i in range(v.shape[0]):
# if v[i] != i: return False
# return True
s = np.arange(v.shape[1])
if v[s] != s: return False
return True
| # 0005, 2022-04-28 08:08:23, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
# for i in range(v.shape[0]):
# if v[i] != i: return False
# return True
s = np.arange(v.shape[1])
if np.sum(v[s] != s) != 0:
return False
return True
| # 0006, 2022-04-28 08:09:43, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
# for i in range(v.shape[0]):
# if v[i] != i: return False
# return True
s = np.arange(len(v))
if np.sum(v[s] != s) != 0:
return False
return True
| # 0007, 2022-04-28 08:12:34, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
# for i in range(v.shape[0]):
# if v[i] != i: return False
# return True
s = np.arange(v.shape[0])
if np.sum(v[s] != s) != 0:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
i = np.arange(0,n)
return u[i] + v[n-i-1]
| # 0008, 2022-04-28 08:13:00, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
# for i in range(v.shape[0]):
# if v[i] != i: return False
# return True
s = np.arange(v.shape[0])
if np.sum(v[s] != s) != 0:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
i = np.arange(0,n)
return u[i] + v[n-i-1]
| # 0009, 2022-04-28 08:13:28, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
# for i in range(v.shape[0]):
# if v[i] != i: return False
# return True
s = np.arange(v.shape[0])
if np.sum(v[s] != s) != 0:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
i = np.arange(0,n)
return u[i] + v[n-i-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M * v
| # 0010, 2022-04-28 08:14:39, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
# for i in range(v.shape[0]):
# if v[i] != i: return False
# return True
s = np.arange(v.shape[0])
if np.sum(v[s] != s) != 0:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
i = np.arange(0,n)
return u[i] + v[n-i-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M * v
| # 0011, 2022-04-28 08:15:30, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
# for i in range(v.shape[0]):
# if v[i] != i: return False
# return True
s = np.arange(v.shape[0])
if np.sum(v[s] != s) != 0:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
i = np.arange(0,n)
return u[i] + v[n-i-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M * v
for k in range(int(input())):
exec(input().strip())
| # 0012, 2022-04-28 08:16:26, PxP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
# for i in range(v.shape[0]):
# if v[i] != i: return False
# return True
s = np.arange(v.shape[0])
if np.sum(v[s] != s) != 0:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
i = np.arange(0,n)
return u[i] + v[u.shape[0]-i-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M * v
for k in range(int(input())):
exec(input().strip())
| # 0013, 2022-04-28 08:17:04, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
# for i in range(v.shape[0]):
# if v[i] != i: return False
# return True
s = np.arange(v.shape[0])
if np.sum(v[s] != s) != 0:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
x = u.shape[0
i = np.arange(0,n)
return u[i] + v[x-i-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M * v
for k in range(int(input())):
exec(input().strip())
|
# 0014, 2022-04-28 08:07:17, --- (0%)
def f1(v):
for i in range(v.shape[0]):
# if v[i] != i:
# return False
# return True
return np.sum(v != np.arange(v.shape[0])) == 0
def f2(u, v):
# u and v are 1-D numpy array of equal size
# n = u.shape[0]
# return np.array([u[i]+v[n-i-1] for i in range(n)])
return u[::] + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
# A = []
# for i in range(M.shape[0]):
# a = []
# for j in range(M.shape[1]):
# a.append(M[i, j] * v[j])
# A.append(a)
# return np.array(A)
return M * v.reshape(v.shape[0], 1)
| # 0015, 2022-04-28 08:07:55, --- (0%)
def f1(v):
# for i in range(v.shape[0]):
# if v[i] != i:
# return False
# return True
return np.sum(v != np.arange(v.shape[0])) == 0
def f2(u, v):
# u and v are 1-D numpy array of equal size
# n = u.shape[0]
# return np.array([u[i]+v[n-i-1] for i in range(n)])
return u[::] + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
# A = []
# for i in range(M.shape[0]):
# a = []
# for j in range(M.shape[1]):
# a.append(M[i, j] * v[j])
# A.append(a)
# return np.array(A)
return M * v.reshape(v.shape[0], 1)
| # 0016, 2022-04-28 08:08:13, --- (0%)
def f1(v):
# for i in range(v.shape[0]):
# if v[i] != i:
# return False
# return True
return np.sum(v != np.arange(v.shape[0])) == 0
def f2(u, v):
# u and v are 1-D numpy array of equal size
# n = u.shape[0]
# return np.array([u[i]+v[n-i-1] for i in range(n)])
return u[::] + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
# A = []
# for i in range(M.shape[0]):
# a = []
# for j in range(M.shape[1]):
# a.append(M[i, j] * v[j])
# A.append(a)
# return np.array(A)
return M * v.reshape(v.shape[0], 1)
| # 0017, 2022-04-28 08:09:17, --- (0%)
def f1(v):
return np.sum(v != np.arange(v.shape[0])) == 0
def f2(u, v):
return u[::] + v[::-1]
def f3(M, v):
return M * v.reshape(v.shape[0], 1)
| # 0018, 2022-04-28 08:09:46, --- (0%)
def f1(v):
return np.sum(v != np.arange(v.shape[0])) == 0
def f2(u, v):
return u[::] + v[::-1]
def f3(M, v):
return M * v.reshape(v.shape[0], 1)
| # 0019, 2022-04-28 08:11:52, --- (0%)
def f1(v):
# if v[i] != i:
# return False
# return True
return np.sum(v != np.arange(v.shape[0])) == 0
def f2(u, v):
# u and v are 1-D numpy array of equal size
# n = u.shape[0]
# return np.array([u[i]+v[n-i-1] for i in range(n)])
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
# A = []
# for i in range(M.shape[0]):
# a = []
# for j in range(M.shape[1]):
# a.append(M[i, j] * v[j])
# A.append(a)
# return np.array(A)
return M * v
| # 0020, 2022-04-28 08:11:57, --- (0%)
def f1(v):
# if v[i] != i:
# return False
# return True
return np.sum(v != np.arange(v.shape[0])) == 0
def f2(u, v):
# u and v are 1-D numpy array of equal size
# n = u.shape[0]
# return np.array([u[i]+v[n-i-1] for i in range(n)])
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
# A = []
# for i in range(M.shape[0]):
# a = []
# for j in range(M.shape[1]):
# a.append(M[i, j] * v[j])
# A.append(a)
# return np.array(A)
return M * v
| # 0021, 2022-04-28 08:12:20, --- (0%)
def f1(v):
# if v[i] != i:
# return False
# return True
checker=np.arrange(v.shape[0])
return np.array_equal(v,checker)
def f2(u, v):
# u and v are 1-D numpy array of equal size
# n = u.shape[0]
# return np.array([u[i]+v[n-i-1] for i in range(n)])
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
# A = []
# for i in range(M.shape[0]):
# a = []
# for j in range(M.shape[1]):
# a.append(M[i, j] * v[j])
# A.append(a)
# return np.array(A)
return M * v
| # 0022, 2022-04-28 08:13:11, xxx (0%)
def f1(v):
# if v[i] != i:
# return False
# return True
checker=np.arrange(v.shape[0])
return np.array_equal(v,checker)
def f2(u, v):
# u and v are 1-D numpy array of equal size
# n = u.shape[0]
# return np.array([u[i]+v[n-i-1] for i in range(n)])
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
# A = []
# for i in range(M.shape[0]):
# a = []
# for j in range(M.shape[1]):
# a.append(M[i, j] * v[j])
# A.append(a)
# return np.array(A)
return M * v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0023, 2022-04-28 08:13:27, xxx (0%)
def f1(v):
# if v[i] != i:
# return False
# return True
return np.sum(v != np.arange(v.shape[0])) == 0
def f2(u, v):
# u and v are 1-D numpy array of equal size
# n = u.shape[0]
# return np.array([u[i]+v[n-i-1] for i in range(n)])
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
# A = []
# for i in range(M.shape[0]):
# a = []
# for j in range(M.shape[1]):
# a.append(M[i, j] * v[j])
# A.append(a)
# return np.array(A)
return M * v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0024, 2022-04-28 08:14:43, PPP (100%)
import numpy as np
def f1(v):
# if v[i] != i:
# return False
# return True
return np.sum(v != np.arange(v.shape[0])) == 0
def f2(u, v):
# u and v are 1-D numpy array of equal size
# n = u.shape[0]
# return np.array([u[i]+v[n-i-1] for i in range(n)])
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
# A = []
# for i in range(M.shape[0]):
# a = []
# for j in range(M.shape[1]):
# a.append(M[i, j] * v[j])
# A.append(a)
# return np.array(A)
return M * v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0025, 2022-04-28 08:07:00, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(len(v))
if np.sum(a==v) > 0:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return np.array(list(u[:]) + list(v[::-1]))
| # 0026, 2022-04-28 08:07:57, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(len(v))
if np.sum(a==v) == 0:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return np.array(list(u[:]) + list(v[::-1]))
| # 0027, 2022-04-28 08:08:47, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(len(v))
if np.sum(a==v) == len(a):
return True
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
return np.array(list(u[:]) + list(v[::-1]))
| # 0028, 2022-04-28 08:09:14, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(len(v))
if np.sum(a==v) == len(a)-1:
return True
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
return np.array(list(u[:]) + list(v[::-1]))
| # 0029, 2022-04-28 08:10:05, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(v.shape[0])
if np.sum(a==v) < v.shape[0]:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return np.array(list(u[:]) + list(v[::-1]))
| # 0030, 2022-04-28 08:10:51, P-x (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(v.shape[0])
if np.sum(a==v) < v.shape[0]:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return np.array(list(u[:]) + list(v[::-1]))
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0031, 2022-04-28 08:11:33, P-x (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(v.shape[0])
if np.sum(a==v) < v.shape[0]:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return np.array(list(u[:]) + list(v[-1::-1]))
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0032, 2022-04-28 08:11:55, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(v.shape[0])
if np.sum(a==v) < v.shape[0]:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return np.array(list(u[0,:]) + list(v[0,-1::-1]))
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0033, 2022-04-28 08:12:07, P-x (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(v.shape[0])
if np.sum(a==v) < v.shape[0]:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return np.array(list(u) + list(v[-1::-1]))
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0034, 2022-04-28 08:14:50, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(v.shape[0])
if np.sum(a==v) < v.shape[0]:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
a = u
b = v[::-1]
return a+b
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0035, 2022-04-28 08:16:20, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(v.shape[0])
if np.sum(a==v) < v.shape[0]:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
a = u
b = v[::-1]
return a+b
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0036, 2022-04-28 08:08:22, compilation error (0%) import numpy as np def f1(v): # v: 1-D numpy array for i in range(v.shape[0]): if v[i] != i: return False return True def f2(u, v): # u and v are 1-D numpy array of equal size n = u.shape[0] return np.array(u+v[::-1]) def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] A = [] for i in range(M.shape[0]): a = [] for j in range(M.shape[1]): a.append(M[i,j] * v[j]) A.append(a) return np.array(A) | # 0037, 2022-04-28 08:09:06, compilation error (0%) import numpy as np def f1(v): # v: 1-D numpy array for i in range(v.shape[0]): if v[i] != i: return False return True def f2(u, v): # u and v are 1-D numpy array of equal size return np.array(u+v[::-1]) def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] A = [] for i in range(M.shape[0]): a = [] for j in range(M.shape[1]): a.append(M[i,j] * v[j]) A.append(a) return np.array(A) | # 0038, 2022-04-28 08:09:20, compilation error (0%) import numpy as np def f1(v): # v: 1-D numpy array for i in range(v.shape[0]): if v[i] != i: return False return True def f2(u, v): # u and v are 1-D numpy array of equal size return u+v[::-1] def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] A = [] for i in range(M.shape[0]): a = [] for j in range(M.shape[1]): a.append(M[i,j] * v[j]) A.append(a) return np.array(A) | # 0039, 2022-04-28 08:09:39, compilation error (0%) import numpy as np def f1(v): # v: 1-D numpy array for i in range(v.shape[0]): if v[i] != i: return False return True def f2(u, v): # u and v are 1-D numpy array of equal size return u+v[::-1] def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] A = [] for i in range(M.shape[0]): a = [] for j in range(M.shape[1]): a.append(M[i,j] * v[j]) A.append(a) return np.array(A) | # 0040, 2022-04-28 08:11:44, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
test = np.arange(len(v))
if len(test[test==v]) != len(v):
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u+v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
| # 0041, 2022-04-28 08:12:11, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
test = np.arange(len(v))
if len(test[test==v]) != len(v):
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u+v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
for k in range(int(input())):
exec(input().strip())
| # 0042, 2022-04-28 08:13:03, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
test = np.arange(len(v))
if len(test[test==v]) != len(v):
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u+v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
for k in range(int(input())):
exec(input().strip())
| # 0043, 2022-04-28 08:15:23, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if len(np.arange(len(v))[np.arange(len(v))==v]) != len(v):
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u+v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
for k in range(int(input())):
exec(input().strip())
| # 0044, 2022-04-28 08:16:37, compilation error (0%)
def f1(v):
# v: 1-D numpy array
test = np.arange(len(v))
if len(test[test==v]) != len(v):
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array(u+v[::-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0045, 2022-04-28 08:17:07, xxx (0%)
def f1(v):
# v: 1-D numpy array
test = np.arange(len(v))
if len(test[test==v]) != len(v):
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u+v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0046, 2022-04-28 08:06:22, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arrange(len(v))
k = a == v
z = True
if np.sum(k) > 0:
z = False
return z
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0047, 2022-04-28 08:06:50, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arrange(len(v))
k = a == v
z = True
if np.sum(k) > 0:
z = False
return z
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0048, 2022-04-28 08:08:10, -xx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(len(v))
k = a == v
z = True
if np.sum(k) > 0:
z = False
return z
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0049, 2022-04-28 08:10:32, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(len(v))
k = a == v
z = True
if np.sum(k) < len(v):
z = False
return z
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0050, 2022-04-28 08:13:03, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(len(v))
k = a == v
z = True
if np.sum(k) < len(v):
z = False
return z
def f2(u, v):
# u and v are 1-D numpy array of equal size
a = u[::]
b = v[len(v)::-1]
c = x+y
return np.array(c)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0051, 2022-04-28 08:13:24, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(len(v))
k = a == v
z = True
if np.sum(k) < len(v):
z = False
return z
def f2(u, v):
# u and v are 1-D numpy array of equal size
a = u[::]
b = v[len(v)::-1]
c = x+y
return c
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0052, 2022-04-28 08:14:12, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(len(v))
k = a == v
z = True
if np.sum(k) < len(v):
z = False
return z
def f2(u, v):
# u and v are 1-D numpy array of equal size
a = u[::]
b = v[len(v)::-1]
c = a+b
return c
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0053, 2022-04-28 08:14:46, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(len(v))
k = a == v
z = True
if np.sum(k) < len(v):
z = False
return z
def f2(u, v):
# u and v are 1-D numpy array of equal size
a = u[::]
b = v[len(v)::-1]
c = a+b
return c
def f3(M, v):
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0054, 2022-04-28 08:15:17, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(len(v))
k = a == v
z = True
if np.sum(k) < len(v):
z = False
return z
def f2(u, v):
# u and v are 1-D numpy array of equal size
a = u[::]
b = v[len(v)::-1]
c = a+b
return c
def f3(M, v):
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0055, 2022-04-28 08:04:42, --- (0%)
import numpy as np
def f1(v) :
return v[v != np.arange(v.shape[0])]
| # 0056, 2022-04-28 08:04:52, --- (0%)
import numpy as np
def f1(v) :
return v[v == np.arange(v.shape[0])]
| # 0057, 2022-04-28 08:05:39, -xx (0%)
import numpy as np
def f1(v) :
return v[v == np.arange(v.shape[0])]
for k in range(int(input())):
exec(input().strip())
| # 0058, 2022-04-28 08:05:52, -xx (0%)
import numpy as np
def f1(v) :
return v[v != np.arange(v.shape[0])]
for k in range(int(input())):
exec(input().strip())
| # 0059, 2022-04-28 08:07:58, -Px (33%)
import numpy as np
def f1(v) :
return v[v != np.arange(v.shape[0])]
def f2(u,v) :
return u + v[::-1]
for k in range(int(input())):
exec(input().strip())
| # 0060, 2022-04-28 08:10:07, -Px (33%)
import numpy as np
def f1(v) :
return v[v != np.arange(v.shape[0])]
def f2(u,v) :
return u + v[::-1]
def f3(M,v) :
return M * v.reshape((M.shape[1],1))
for k in range(int(input())):
exec(input().strip())
| # 0061, 2022-04-28 08:13:22, -PP (67%)
import numpy as np
def f1(v) :
return v[v != np.arange(v.shape[0])]
def f2(u,v) :
return u + v[::-1]
def f3(M,v) :
return M * v
for k in range(int(input())):
exec(input().strip())
| # 0062, 2022-04-28 08:15:09, -PP (67%)
import numpy as np
def f1(v) :
return np.sum(v[v != np.arange(v.shape[0])]) != 0
def f2(u,v) :
return u + v[::-1]
def f3(M,v) :
return M * v
for k in range(int(input())):
exec(input().strip())
| # 0063, 2022-04-28 08:15:51, PPP (100%)
import numpy as np
def f1(v) :
return np.sum(v[v != np.arange(v.shape[0])]) == 0
def f2(u,v) :
return u + v[::-1]
def f3(M,v) :
return M * v
for k in range(int(input())):
exec(input().strip())
|
# 0064, 2022-04-28 08:07:00, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x = np.arange(v.shape[0])
t = np.sum(v == x)
if t != len(v):
return False
return True
| # 0065, 2022-04-28 08:07:40, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x = np.arange(v.shape[0])
t = np.sum(v == x)
if t != v.shape[0]:
return False
return True
| # 0066, 2022-04-28 08:08:01, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x = np.arange(v.shape[0])
t = np.sum(v == x)
if t != v.shape[0]:
return False
return True
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0067, 2022-04-28 08:09:59, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x = np.arange(v.shape[0])
t = np.sum(v == x)
if t != v.shape[0]:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u + v[::-1]
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0068, 2022-04-28 08:13:31, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x = np.arange(v.shape[0])
t = np.sum(v == x)
if t != v.shape[0]:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u + v[::-1]
def f(M, v):
return M.dot(v.T)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0069, 2022-04-28 08:14:16, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x = np.arange(v.shape[0])
t = np.sum(v == x)
if t != v.shape[0]:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u + v[::-1]
def f(M, v):
return M.dot(v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0070, 2022-04-28 08:15:10, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x = np.arange(v.shape[0])
t = np.sum(v == x)
if t != v.shape[0]:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u + v[::-1]
def f(M, v):
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0071, 2022-04-28 08:16:23, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x = np.arange(v.shape[0])
t = np.sum(v == x)
if t != v.shape[0]:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u + v[::-1]
def f(M, v):
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0072, 2022-04-28 08:16:37, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x = np.arange(v.shape[0])
t = np.sum(v == x)
if t != v.shape[0]:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u + v[::-1]
def f3(M, v):
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0073, 2022-04-28 08:04:16, --- (0%)
def f1(v):
# v: 1-D numpy array
return np.arange(len(v))
| # 0074, 2022-04-28 08:04:35, xxx (0%)
def f1(v):
# v: 1-D numpy array
return np.arange(len(v))
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0075, 2022-04-28 08:05:40, xxx (0%)
def f1(v):
# v: 1-D numpy array
if v == np.arange(len(v)):
return True
else:
return False
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0076, 2022-04-28 08:06:49, xxx (0%)
def f1(v):
# v: 1-D numpy array
if v == np.arange(0,len(v)):
return True
else:
return False
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0077, 2022-04-28 08:07:05, xxx (0%)
def f1(v):
# v: 1-D numpy array
if v == np.arange(0,len(v),1):
return True
else:
return False
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0078, 2022-04-28 08:07:50, xxx (0%)
def f1(v):
# v: 1-D numpy array
if all(v == np.arange(len(v))):
return True
else:
return False
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0079, 2022-04-28 08:08:32, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if all(v == np.arange(len(v))):
return True
else:
return False
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0080, 2022-04-28 08:10:09, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if all(v == np.arange(len(v))):
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
new = v[::-1]
return u + new
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0081, 2022-04-28 08:12:40, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if all(v == np.arange(len(v))):
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
new = v[::-1]
return u + new
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M * v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0082, 2022-04-28 08:08:48, xxx (0%)
import numpy as np
def f1(v):
a = v[:: ] == i
return a
for k in range(int(input())):
exec(input().strip())
| # 0083, 2022-04-28 08:12:59, compilation error (0%)
import numpy as np
def f1(v):
b = np.arange( len{v})
a = b ==v
if np.sum(a ) == len(v):
return True
return False
for k in range(int(input())):
exec(input().strip())
| # 0084, 2022-04-28 08:14:01, compilation error (0%)
import numpy as np
def f1(v):
b = np.arange( len{v})
a = b ==v
if np.sum(a ) == len(v):
return True
return False
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
for k in range(int(input())):
exec(input().strip())
| # 0085, 2022-04-28 08:14:57, compilation error (0%)
import numpy as np
def f1(v):
b = np.arange( len{v})
a = b ==v
if np.sum(a ) == len(v):
return True
return False
def f2(u,v):
n = u.shape[0]
ans = u[ i:n+1] + v[ n-1 : :-1 ]
return ans
def f3(M, v):
return M*v
for k in range(int(input())):
exec(input().strip())
| # 0086, 2022-04-28 08:15:03, compilation error (0%)
import numpy as np
def f1(v):
b = np.arange( len{v})
a = b ==v
if np.sum(a ) == len(v):
return True
return False
def f2(u,v):
n = u.shape[0]
ans = u[ i:n+1] + v[ n-1 : :-1 ]
return ans
def f3(M, v):
return M*v
for k in range(int(input())):
exec(input().strip())
| # 0087, 2022-04-28 08:15:52, compilation error (0%)
import numpy as np
def f1(v):
b = np.arange(len{v})
a = b ==v
if np.sum(a ) == len(v):
return True
return False
def f2(u,v):
n = u.shape[0]
ans = u[ i:n+1] + v[ n-1 : :-1 ]
return ans
def f3(M, v):
return M*v
for k in range(int(input())):
exec(input().strip())
| # 0088, 2022-04-28 08:16:03, PxP (67%)
import numpy as np
def f1(v):
b = np.arange(len(v))
a = b ==v
if np.sum(a ) == len(v):
return True
return False
def f2(u,v):
n = u.shape[0]
ans = u[ i:n+1] + v[ n-1 : :-1 ]
return ans
def f3(M, v):
return M*v
for k in range(int(input())):
exec(input().strip())
| # 0089, 2022-04-28 08:16:20, PPP (100%)
import numpy as np
def f1(v):
b = np.arange(len(v))
a = b ==v
if np.sum(a ) == len(v):
return True
return False
def f2(u,v):
return u + v[::-1]
def f3(M, v):
return M*v
for k in range(int(input())):
exec(input().strip())
|
# 0090, 2022-04-28 08:07:45, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
position = np.arange(v.shape[0])
if np.sum(postion == v) == len(v) :
return True
else :
return False
| # 0091, 2022-04-28 08:08:19, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
position = np.arange(v.shape[0])
if np.sum(postion == v) == len(v) :
return True
else :
return False
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0092, 2022-04-28 08:09:28, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(v.shape[0])
if np.sum( == v) == len(v) :
return True
else :
return False
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0093, 2022-04-28 08:09:44, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(v.shape[0])
if np.sum(pos == v) == len(v) :
return True
else :
return False
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0094, 2022-04-28 08:10:35, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(v.shape[0])
if np.sum(pos == v) == len(v) :
return True
else :
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
return
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0095, 2022-04-28 08:14:58, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(v.shape[0])
if np.sum(pos == v) == len(v) :
return True
else :
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
size = u.shape[0]
pos = np.arange(size)
return u[pos] + v[size - pos - 1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M[:] * v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0096, 2022-04-28 08:15:35, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(v.shape[0])
if np.sum(pos == v) == len(v) :
return True
else :
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
size = u.shape[0]
pos = np.arange(size)
return u[pos] + v[size - pos - 1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M[:] * v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0097, 2022-04-28 08:16:40, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(v.shape[0])
if np.sum(pos == v) == len(v) :
return True
else :
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
size = u.shape[0]
pos = np.arange(size)
return u[pos] + v[size - pos - 1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M[:] * v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0098, 2022-04-28 08:09:21, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
id=np.arange(0,v.shape[0])
x=v != id
if sum(x) != 0: return False
else :
return True
'''for i in range(v.shape[0]):
if v[i] != i: return False
return True'''
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0] #row
x=u+v[-1]
return x
#return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
x=v*M
return v*M
''' A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)'''
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0099, 2022-04-28 08:09:48, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
id=np.arange(0,v.shape[0])
x=v != id
if sum(x) != 0: return False
else :
return True
'''for i in range(v.shape[0]):
if v[i] != i: return False
return True'''
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0] #row
x=u+v[-1]
return x
#return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
x=v*M
return x
''' A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)'''
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0100, 2022-04-28 08:10:49, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
id=np.arange(0,v.shape[0])
x=v != id
if sum(x) != 0: return False
else :
return True
'''for i in range(v.shape[0]):
if v[i] != i: return False
return True'''
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0] #row
x=u+v[-1]
return x
#return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
x=v*M
return x
''' A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)'''
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0101, 2022-04-28 08:12:57, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
id=np.arange(0,v.shape[0])
x=v != id
if sum(x) != 0: return False
else :
return True
'''for i in range(v.shape[0]):
if v[i] != i: return False
return True'''
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u[:]+v[::-1]
#return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M[:]*v
''' A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)'''
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0102, 2022-04-28 08:13:44, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
id=np.arange(0,v.shape[0])
x=v != id
if sum(x) != 0: return False
else : retrun True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u[:]+v[::-1]
#return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M[:]*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0103, 2022-04-28 08:14:32, PPP (100%)
import numpy as np
def f1(v):
return np.sum(np.arange(v.shape[0])!=v)==0
def f2(u, v):
return u[:]+v[::-1]
def f3(M, v):
return M[:]*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0104, 2022-04-28 08:15:06, PPP (100%)
import numpy as np
def f1(v):
return np.sum(np.arange(v.shape[0])!=v)==0
def f2(u, v):
return u[:]+v[::-1]
def f3(M, v):
return M[:]*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0105, 2022-04-28 08:15:49, PPP (100%)
import numpy as np
def f1(v):
x=np.sum(np.arange(v.shape[0])!=v)==0
return x
def f2(u, v):
return u[:]+v[::-1]
def f3(M, v):
return M[:]*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0106, 2022-04-28 08:13:07, compilation error (0%) import numpy as np def f1(v): x = np.arange(0,v.shape[0],1) output = np.sum(v == x) == v.shape[0] return output def f2(u, v): n = u.shape[0] output = u + v[::-1] return output def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] A = [] for i in range(M.shape[0]): a = [] for j in range(M.shape[1]): a.append(M[i,j] * v[j]) A.append(a) return np.array(A) #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0107, 2022-04-28 08:13:50, compilation error (0%) import numpy as np def f1(v): x = np.arange(0,v.shape[0],1) return np.sum(v == x) == v.shape[0] def f2(u, v): n = u.shape[0] output = u + v[::-1] return output def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] A = [] for i in range(M.shape[0]): a = [] for j in range(M.shape[1]): a.append(M[i,j] * v[j]) A.append(a) return np.array(A) #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0108, 2022-04-28 08:14:03, compilation error (0%) import numpy as np def f1(v): x = np.arange(0,v.shape[0],1) return np.sum(v == x) == v.shape[0] def f2(u, v): n = u.shape[0] output = u + v[::-1] return output def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] A = [] for i in range(M.shape[0]): a = [] for j in range(M.shape[1]): a.append(M[i,j] * v[j]) A.append(a) return np.array(A) #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0109, 2022-04-28 08:15:23, PPP (100%)
import numpy as np
def f1(v):
x = np.arange(0,v.shape[0],1)
return np.sum(v == x) == v.shape[0]
def f2(u, v):
n = u.shape[0]
output = u + v[::-1]
return output
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0110, 2022-04-28 08:15:57, PPP (100%)
import numpy as np
def f1(v):
x = np.arange(0,v.shape[0],1)
return np.sum(v == x) == v.shape[0]
def f2(u, v):
n = u.shape[0]
output = u + v[::-1]
return output
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0111, 2022-04-28 08:16:35, PPP (100%)
import numpy as np
def f1(v):
x = np.arange(0,v.shape[0],1)
return np.sum(v == x) == v.shape[0]
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0112, 2022-04-28 08:17:02, compilation error (0%)
import numpy as np
def f1(v):
x = np.arange(0,v.shape[0],1)
return np.sum(v == x) == v.shape[0]
def f2(u, v):
# u and v are 1-D numpy array of equal size
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0113, 2022-04-28 08:17:16, compilation error (0%)
import numpy as np
def f1(v):
x = np.arange(0,v.shape[0],1)
return np.sum(v == x) == v.shape[0]
def f2(u, v):
# u and v are 1-D numpy array of equal size
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0114, 2022-04-28 08:09:07, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i = np.arange(len(v))
if np.sum(v==i) :
return True
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0115, 2022-04-28 08:09:35, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i = np.arange(len(v))
if np.sum(v==i) :
return True
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u + v[::-1]
----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0116, 2022-04-28 08:10:04, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i = np.arange(len(v))
if np.sum(v==i) :
return True
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u + v[::-1]
----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0117, 2022-04-28 08:10:49, compilation error (0%)
import numpy as np
def f1(v):
num = np.arange(len(v))
con = num[num == v]
if len(con) == len(v):
return True
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u + v[::-1]
----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0118, 2022-04-28 08:11:34, compilation error (0%)
import numpy as np
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A
----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0119, 2022-04-28 08:13:11, compilation error (0%)
import numpy as np
def f1(v):
num = np.arange(len(v))
con = num[num == v]
if len(con) == len(v):
return True
return False
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M * v
----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0120, 2022-04-28 08:13:39, --- (0%)
import numpy as np
def f1(v):
num = np.arange(len(v))
con = num[num == v]
if len(num[con]) == len(v):
return True
return False
def f2(u, v):
return u + v[::-1]
def f3(M, v):
return M * v
exec(input().strip())
| # 0121, 2022-04-28 08:13:59, PPP (100%)
import numpy as np
def f1(v):
num = np.arange(len(v))
con = num[num == v]
if len(num[con]) == len(v):
return True
return False
def f2(u, v):
return u + v[::-1]
def f3(M, v):
return M * v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0122, 2022-04-28 08:08:58, -Px (33%)
import numpy as np;
def f1(v):
want = np.arange(0,len(v),1)
fin = want[want == v]
if (len(want) == len(v)):
return True
return False
def f2(u,v):
return u + v[::-1]
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0123, 2022-04-28 08:09:46, -Px (33%)
import numpy as np
def f1(v):
want = np.arange(0,len(v),1)
fin = want[want == v]
if (len(want) == len(v)):
return True
return False
def f2(u,v):
return u + v[::-1]
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0124, 2022-04-28 08:12:45, -PP (67%)
import numpy as np;
def f1(v):
want = np.arange(0,len(v),1)
fin = want[want == v]
if (len(want) == len(v)):
return True
return False
def f2(u,v):
return u + v[::-1]
def f3(M,v):
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0125, 2022-04-28 08:14:03, PPP (100%)
import numpy as np
def f1(v):
want = np.arange(0,len(v),1)
fin = want[want == v]
if (len(fin) == len(v)):
return True
return False
def f2(u,v):
return u + v[::-1]
def f3(M,v):
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0126, 2022-04-28 08:14:45, PPP (100%)
import numpy as np;
def f1(v):
want = np.arange(0,len(v),1)
fin = want[want == v]
if (len(fin) == len(v)):
return True
return False
def f2(u,v):
return u + v[::-1]
def f3(M,v):
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0127, 2022-04-28 08:16:03, PPP (100%)
import numpy as np
def f1(v):
want = np.arange(0,len(v),1)
fin = want[want == v]
if (len(fin) == len(v)):
return True
return False
def f2(u,v):
return u + v[::-1]
def f3(M,v):
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0128, 2022-04-28 08:17:13, -PP (67%)
import numpy as np;
def f1(v):
want = np.arange(0,len(v),1)
fin = want[want == v]
if (len(want) == len(v)):
return True
return False
def f2(u,v):
return u + v[::-1]
def f3(M,v):
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0129, 2022-04-28 08:09:46, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(0,v.shape[0],1)
if v == a:
return True
else:
return False
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0130, 2022-04-28 08:12:08, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(0,v.shape[0],1)
if v == a:
return True
else:
return False
def f2(u,v):
a1 = u[::]
a2 = v[-1::]
pass a1 + a2
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0131, 2022-04-28 08:12:57, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(0,v.shape[0],1)
if v == a:
return True
else:
return False
def f2(u,v):
a1 = u[::]
a2 = v[-1::]
pass a1 + a2
return np.array([u[i]+v[n-i-1] for i in range(n)])
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0132, 2022-04-28 08:13:19, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(0,v.shape[0],1)
if v == a:
return True
else:
return False
def f2(u,v):
a1 = u[::]
a2 = v[-1::]
return a1 + a
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0133, 2022-04-28 08:13:56, xxP (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(0,v.shape[0],1)
if v == a:
return True
else:
return False
def f2(u,v):
a1 = u[::]
a2 = v[-1::]
return a1 + a
def f3(M, v):
res = M * v
return res
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0134, 2022-04-28 08:14:49, xx- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(0,v.shape[0],1)
if v == a:
return True
else:
return False
def f2(u,v):
a1 = u[::]
a2 = v[-1::]
return a1 + a
def f3(M,v):
return M.dot(v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0135, 2022-04-28 08:15:20, PPP (100%)
import numpy as np
def f1(v):
res = np.min(v == np.arange(v.shape[0]))
return res
def f2(M, v):
res = M + v[::-1]
return res
def f3(M, v):
res = M * v
return res
for k in range(int(input())):
exec(input().strip())
|
# 0136, 2022-04-28 08:07:54, x-P (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
# for i in range(v.shape[0]):
# if v[i] != i: return False
# return True
index = np.arrange(v.shape[0])
check = np.sum(v[v == index])
if check!=v.shape[0]:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u+v[v.shape[0]-u.shape[0]::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
# A = []
# for i in range(M.shape[0]):
# a = []
# for j in range(M.shape[1]):
# a.append(M[i,j] * v[j])
# A.append(a)
# return np.array(A)
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0137, 2022-04-28 08:09:22, x-P (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
index = np.arrange(v.shape[0])
check = np.sum(v[v == index])
if check!=v.shape[0]:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u+v[v.shape[0]-u.shape[0]::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
# A = []
# for i in range(M.shape[0]):
# a = []
# for j in range(M.shape[1]):
# a.append(M[i,j] * v[j])
# A.append(a)
# return np.array(A)
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0138, 2022-04-28 08:10:18, x-P (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
index = np.arrange(v.shape[0])
check = np.sum(v == index)
if check!=v.shape[0]:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u+v[v.shape[0]-u.shape[0]::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
# A = []
# for i in range(M.shape[0]):
# a = []
# for j in range(M.shape[1]):
# a.append(M[i,j] * v[j])
# A.append(a)
# return np.array(A)
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0139, 2022-04-28 08:11:23, P-P (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return np.sum(v == np.arange(v.shape[0])) == v.shape[0]
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u+v[v.shape[0]-u.shape[0]::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
# A = []
# for i in range(M.shape[0]):
# a = []
# for j in range(M.shape[1]):
# a.append(M[i,j] * v[j])
# A.append(a)
# return np.array(A)
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0140, 2022-04-28 08:11:44, P-P (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return np.sum(v == np.arange(v.shape[0])) == v.shape[0]
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u+v[v.shape[0]-u.shape[0]::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
# A = []
# for i in range(M.shape[0]):
# a = []
# for j in range(M.shape[1]):
# a.append(M[i,j] * v[j])
# A.append(a)
# return np.array(A)
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0141, 2022-04-28 08:12:24, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return np.sum(v == np.arange(v.shape[0])) == v.shape[0]
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u+v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
# A = []
# for i in range(M.shape[0]):
# a = []
# for j in range(M.shape[1]):
# a.append(M[i,j] * v[j])
# A.append(a)
# return np.array(A)
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0142, 2022-04-28 08:12:48, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return np.sum(v == np.arange(v.shape[0])) == v.shape[0]
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u+v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0143, 2022-04-28 08:05:19, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(len(v))
if np.sum(v[:a] != a) != 0 : return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0144, 2022-04-28 08:06:03, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(len(v))
if np.sum(v[a] != a) != 0 : return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0145, 2022-04-28 08:08:15, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(len(v))
if np.sum(v[a] != a) != 0 : return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array(u[0:n]+v[n:])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0146, 2022-04-28 08:10:31, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(len(v))
if np.sum(v[a] != a) != 0 : return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array(u[0:n]+v[n-1::-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0147, 2022-04-28 08:12:35, PP- (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(len(v))
if np.sum(v[a] != a) != 0 : return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array(u[0:n]+v[n-1::-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
A.append(M * v)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0148, 2022-04-28 08:13:26, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(len(v))
if np.sum(v[a] != a) != 0 : return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array(u[0:n]+v[n-1::-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = m*v
return A
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0149, 2022-04-28 08:13:36, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(len(v))
if np.sum(v[a] != a) != 0 : return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array(u[0:n]+v[n-1::-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = M*v
return A
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0150, 2022-04-28 08:07:30, Pxx (33%)
import numpy as np
def f1(v):
x = np.arange(0,len(v))
if np.sum(v == x) == len(v):
return True
else:return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
for k in range(int(input())):
exec(input().strip())
| # 0151, 2022-04-28 08:09:28, PPx (67%)
import numpy as np
def f1(v):
x = np.arange(0,len(v))
if np.sum(v == x) == len(v):
return True
else:return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
x = u[:]
y = v[n::-1]
return np.array(x+y)
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
for k in range(int(input())):
exec(input().strip())
| # 0152, 2022-04-28 08:13:23, PPx (67%)
import numpy as np
def f1(v):
x = np.arange(0,len(v))
if np.sum(v == x) == len(v):
return True
else:return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
x = u[:]
y = v[n::-1]
return np.array(x+y)
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
x = np.arange(0,M.shape[0])
y = np.arange(0,M.shape[1])
A.append(M[x,y] * v[y])
return np.array(A)
for k in range(int(input())):
exec(input().strip())
| # 0153, 2022-04-28 08:14:12, PP- (67%)
import numpy as np
def f1(v):
x = np.arange(0,len(v))
if np.sum(v == x) == len(v):
return True
else:return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
x = u[:]
y = v[n::-1]
return np.array(x+y)
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
x = np.arange(0,M.shape[0])
y = np.arange(0,M.shape[1])
A.append(M * v)
return np.array(A)
for k in range(int(input())):
exec(input().strip())
| # 0154, 2022-04-28 08:14:30, PPP (100%)
import numpy as np
def f1(v):
x = np.arange(0,len(v))
if np.sum(v == x) == len(v):
return True
else:return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
x = u[:]
y = v[n::-1]
return np.array(x+y)
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
x = np.arange(0,M.shape[0])
y = np.arange(0,M.shape[1])
A.append(M * v)
return np.array(M*v)
for k in range(int(input())):
exec(input().strip())
| # 0155, 2022-04-28 08:14:40, PPP (100%)
import numpy as np
def f1(v):
x = np.arange(0,len(v))
if np.sum(v == x) == len(v):
return True
else:return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
x = u[:]
y = v[n::-1]
return np.array(x+y)
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
x = np.arange(0,M.shape[0])
y = np.arange(0,M.shape[1])
A.append(M * v)
return (M*v)
for k in range(int(input())):
exec(input().strip())
|
# 0156, 2022-04-28 08:07:26, compilation error (0%)
import numpy as np
def f1(v):
i = np.arange(v.shape[0])
fv = i[v=i] = i
# v: 1-D numpy array
'''
for i in range(v.shape[0]):
if v[i] != i: return False
return True
'''
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0157, 2022-04-28 08:07:49, compilation error (0%)
import numpy as np
def f1(v):
i = np.arange(v.shape[0])
fv = i[v=i] = i
return fv
# v: 1-D numpy array
'''
for i in range(v.shape[0]):
if v[i] != i: return False
return True
'''
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0158, 2022-04-28 08:08:01, compilation error (0%)
import numpy as np
def f1(v):
i = np.arange(v.shape[0])
fv = i[v=i]
return fv
# v: 1-D numpy array
'''
for i in range(v.shape[0]):
if v[i] != i: return False
return True
'''
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0159, 2022-04-28 08:10:12, Pxx (33%)
import numpy as np
def f1(v):
i = np.arange(v.shape[0])
fv = sum(i==v)
le = v.shape[0]
if le == fv:
return True
return False
# v: 1-D numpy array
'''
for i in range(v.shape[0]):
if v[i] != i: return False
return True
'''
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0160, 2022-04-28 08:12:02, PPx (67%)
import numpy as np
def f1(v):
i = np.arange(v.shape[0])
fv = sum(i==v)
le = v.shape[0]
if le == fv:
return True
return False
# v: 1-D numpy array
'''
for i in range(v.shape[0]):
if v[i] != i: return False
return True
'''
def f2(u, v):
return u[::]+v[::-1]
# u and v are 1-D numpy array of equal size
'''
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
'''
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0161, 2022-04-28 08:13:35, PPP (100%)
import numpy as np
def f1(v):
i = np.arange(v.shape[0])
fv = sum(i==v)
le = v.shape[0]
if le == fv:
return True
return False
# v: 1-D numpy array
'''
for i in range(v.shape[0]):
if v[i] != i: return False
return True
'''
def f2(u, v):
return u[::]+v[::-1]
# u and v are 1-D numpy array of equal size
'''
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
'''
def f3(M, v):
return M*v
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
'''
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
'''
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0162, 2022-04-28 08:05:08, xPP (67%) import numpy as np def f1(v): # v: 1-D numpy array return v == np.arange(v.ashape[0]) def f2(u, v): # u and v are 1-D numpy array of equal size return u[:] + v[u.shape[0]::-1] def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] return M * v #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0163, 2022-04-28 08:05:31, xPP (67%) import numpy as np def f1(v): # v: 1-D numpy array return v == np.arange(v.ashape[0]+1) def f2(u, v): # u and v are 1-D numpy array of equal size return u[:] + v[u.shape[0]::-1] def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] return M * v #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0164, 2022-04-28 08:06:57, xPP (67%) import numpy as np def f1(v): # v: 1-D numpy array return v == np.arange(v.ahape[0]) def f2(u, v): # u and v are 1-D numpy array of equal size return u[:] + v[u.shape[0]::-1] def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] return M * v #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0165, 2022-04-28 08:07:18, -PP (67%) import numpy as np def f1(v): # v: 1-D numpy array return v == np.arange(v.shape[0]) def f2(u, v): # u and v are 1-D numpy array of equal size return u[:] + v[u.shape[0]::-1] def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] return M * v #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0166, 2022-04-28 08:08:23, xPP (67%) import numpy as np def f1(v): # v: 1-D numpy array x = np.arange(v.ashape[0]) return np.sum(v == x) def f2(u, v): # u and v are 1-D numpy array of equal size return u[:] + v[u.shape[0]::-1] def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] return M * v #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0167, 2022-04-28 08:10:35, PPP (100%) import numpy as np def f1(v): # v: 1-D numpy array x = np.arange(v.shape[0]) return np.sum(v == x) == v.shape[0] def f2(u, v): # u and v are 1-D numpy array of equal size return u[:] + v[u.shape[0]::-1] def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] return M * v #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) |
# 0168, 2022-04-28 08:01:40, -PP (67%)
import numpy as np
def f1(v) :
x = np.arange(v.shape[0])
b = v==x
if np.sum(b):
return False
else:
return True
def f2(u,v):
return u + v[::-1]
def f3(M,v):
return M*v
for k in range(int(input())):
exec(input().strip())
| # 0169, 2022-04-28 08:02:31, -PP (67%)
import numpy as np
def f1(v) :
x = np.arange(v.shape[0])
b = v==x
if np.sum(b)!=0:
return False
else:
return True
def f2(u,v):
return u + v[::-1]
def f3(M,v):
return M*v
for k in range(int(input())):
exec(input().strip())
| # 0170, 2022-04-28 08:02:39, -PP (67%)
import numpy as np
def f1(v) :
x = np.arange(v.shape[0])
b = v==x
if np.sum(b)==0:
return False
else:
return True
def f2(u,v):
return u + v[::-1]
def f3(M,v):
return M*v
for k in range(int(input())):
exec(input().strip())
| # 0171, 2022-04-28 08:04:37, -PP (67%)
import numpy as np
def f1(v) :
x = np.arange(v.shape[0])
b = v==x
if np.sum(b)!=0:
return False
else:
return True
def f2(u,v):
return u + v[::-1]
def f3(M,v):
return M*v
for k in range(int(input())):
exec(input().strip())
| # 0172, 2022-04-28 08:04:54, xPP (67%)
import numpy as np
def f1(v) :
x = np.arange(v.shape)
b = v==x
if np.sum(b)!=0:
return False
else:
return True
def f2(u,v):
return u + v[::-1]
def f3(M,v):
return M*v
for k in range(int(input())):
exec(input().strip())
| # 0173, 2022-04-28 08:07:37, PPP (100%)
import numpy as np
def f1(v) :
x = np.arange(v.shape[0])
b = v==x
if np.sum(b)==v.shape[0]:
return True
else:
return False
def f2(u,v):
return u + v[::-1]
def f3(M,v):
return M*v
for k in range(int(input())):
exec(input().strip())
|
# 0174, 2022-04-28 08:08:57, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
u = np.arange(v.shape[0])
return len(v[v[u]==u]) == v.shape[0]
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
r = [u+v[::-1]
return r
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.array(M*v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0175, 2022-04-28 08:09:20, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
u = np.arange(v.shape[0])
return len(v[v[u]==u]) == v.shape[0]
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
r = [u+v[::-1]
return r
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.array(M*v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0176, 2022-04-28 08:09:45, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
u = np.arange(v.shape[0])
return len(v[v[u]==u]) == v.shape[0]
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
r = [u+v[::-1]
return r
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.array(M*v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0177, 2022-04-28 08:10:11, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
u = np.arange(v.shape[0])
return len(v[v[u]==u]) == v.shape[0]
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
r = [u+v[::-1]
return r
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.array(M*v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0178, 2022-04-28 08:11:32, PxP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
u = np.arange(v.shape[0])
return len(v[v[u]==u]) == v.shape[0]
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
r = [u+v[::-1]]
return r
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.array(M*v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0179, 2022-04-28 08:12:58, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
u = np.arange(v.shape[0])
return len(v[v[u]==u]) == v.shape[0]
def f2(u, v):
# u and v are 1-D numpy array of equal size
r = u+v[::-1]
return r
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.array(M*v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0180, 2022-04-28 08:08:58, -PP (67%)
import numpy as np
def f1(v):
pos=np.arange(v.shape[0])
return v==pos
def f2(u, v):
pos=np.arange(v.shape[0])
a=u[pos]
b=v[v.shape[0]-pos-1]
return a+b
def f3(M, v):
return v*M
for k in range(int(input())):
exec(input().strip())
| # 0181, 2022-04-28 08:09:58, -PP (67%)
import numpy as np
def f1(v):
pos=np.arange(v.shape[0])
a= v==pos
return a
def f2(u, v):
pos=np.arange(v.shape[0])
a=u[pos]
b=v[v.shape[0]-pos-1]
return a+b
def f3(M, v):
return v*M
for k in range(int(input())):
exec(input().strip())
| # 0182, 2022-04-28 08:10:50, -PP (67%)
import numpy as np
def f1(v):
pos=np.arange(v.shape[0])
a= v[pos]==pos
return a
def f2(u, v):
pos=np.arange(v.shape[0])
a=u[pos]
b=v[v.shape[0]-pos-1]
return a+b
def f3(M, v):
return v*M
for k in range(int(input())):
exec(input().strip())
| # 0183, 2022-04-28 08:11:48, -PP (67%)
import numpy as np
def f1(v):
pos=np.arange(v.shape[0])
a= v[pos]==pos
return a[pos]
def f2(u, v):
pos=np.arange(v.shape[0])
a=u[pos]
b=v[v.shape[0]-pos-1]
return a+b
def f3(M, v):
return v*M
for k in range(int(input())):
exec(input().strip())
| # 0184, 2022-04-28 08:13:54, xPP (67%)
import numpy as np
def f1(v):
pos=np.arange(v.shape[0])
if v[pos]==pos:
return True
else:
return False
def f2(u, v):
pos=np.arange(v.shape[0])
a=u[pos]
b=v[v.shape[0]-pos-1]
return a+b
def f3(M, v):
return v*M
for k in range(int(input())):
exec(input().strip())
| # 0185, 2022-04-28 08:15:27, PPP (100%)
import numpy as np
def f1(v):
pos=np.arange(v.shape[0])
a= v[pos]==pos
if sum(a)==v.shape[0]:
return True
else:
return False
def f2(u, v):
pos=np.arange(v.shape[0])
a=u[pos]
b=v[v.shape[0]-pos-1]
return a+b
def f3(M, v):
return v*M
for k in range(int(input())):
exec(input().strip())
|
# 0186, 2022-04-28 08:09:49, -xP (33%)
import numpy as np
def f1(v):
pos = np.arange(0,v.shape[0])
return
def f2(u, v):
#u0,v4 u1,v3 u2,v2 u3,v1 u4,v0
n = u.shape[0]
return u[0:n] + v[n:-1] #?or -1/0
def f3(M, v):
return v[:] * M[:]
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0187, 2022-04-28 08:10:29, -xP (33%)
import numpy as np
def f1(v):
pos = np.arange(0,v.shape[0])
return
def f2(u, v):
#u0,v4 u1,v3 u2,v2 u3,v1 u4,v0
n = u.shape[0]
return u[0:n] + v[n:0] #?or -1/0
def f3(M, v):
return v[:] * M[:]
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0188, 2022-04-28 08:11:26, PxP (67%)
import numpy as np
def f1(v):
return (np.sum(v == np.arange(v.shape[0])) == v.shape[0])
def f2(u, v):
#u0,v4 u1,v3 u2,v2 u3,v1 u4,v0
n = u.shape[0]
return u[0:n] + v[n:0] #?or -1/0
def f3(M, v):
return v[:] * M[:]
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0189, 2022-04-28 08:12:35, PxP (67%)
import numpy as np
def f1(v):
return (np.sum(v == np.arange(v.shape[0])) == v.shape[0])
def f2(u, v):
#u0,v4 u1,v3 u2,v2 u3,v1 u4,v0
n = u.shape[0]
return u[0:n] + v[n-1:-1:-1] #?or -1/0
def f3(M, v):
return v[:] * M[:]
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0190, 2022-04-28 08:13:27, PPP (100%)
import numpy as np
def f1(v):
return (np.sum(v == np.arange(v.shape[0])) == v.shape[0])
def f2(u, v):
#u0,v4 u1,v3 u2,v2 u3,v1 u4,v0
n = u.shape[0]
return u[0:n] + v[n::-1] #?or -1/0
def f3(M, v):
return v[:] * M[:]
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0191, 2022-04-28 08:13:38, x-P (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if np.min(np.arange(v.shape[0]==v)==1):
return True
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
a=u+v
return a[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0192, 2022-04-28 08:14:06, x-P (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if np.min(np.arange(v.shape[0]==v))==1:
return True
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
a=u+v
return a[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0193, 2022-04-28 08:14:42, P-P (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if np.min(np.arange(v.shape[0])==v)==1:
return True
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
a=u+v
return a[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0194, 2022-04-28 08:15:02, P-P (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if np.min(np.arange(v.shape[0])==v)==1:
return True
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
a=u+v
return a[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0195, 2022-04-28 08:16:06, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if np.min(np.arange(v.shape[0])==v)==1:
return True
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
a=u+v[::-1]
return a
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0196, 2022-04-28 08:12:23, xxx (0%)
def f1(v):
h=np.arange(v.shape[0])
g= v == h
return g
def f2(u, v):
# u and v are 1-D numpy array of equal size
v=v[::-1]
return u+v
def f3(M, v):
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0197, 2022-04-28 08:12:54, -PP (67%)
import numpy as np
def f1(v):
h=np.arange(v.shape[0])
g= v == h
return g
def f2(u, v):
# u and v are 1-D numpy array of equal size
v=v[::-1]
return u+v
def f3(M, v):
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0198, 2022-04-28 08:14:11, -PP (67%)
import numpy as np
def f1(v):
h=np.arange(v.shape[0])
g= v == h
return np.sum(g)
def f2(u, v):
# u and v are 1-D numpy array of equal size
v=v[::-1]
return u+v
def f3(M, v):
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0199, 2022-04-28 08:14:32, xPP (67%)
import numpy as np
def f1(v):
h=np.arange(v.shape[1])
g= v == h
return np.sum(g)
def f2(u, v):
# u and v are 1-D numpy array of equal size
v=v[::-1]
return u+v
def f3(M, v):
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0200, 2022-04-28 08:15:53, PPP (100%)
import numpy as np
def f1(v):
i = np.arange(len(v))
if np.sum(i == v) == len(v) :
return True
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
v=v[::-1]
return u+v
def f3(M, v):
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0201, 2022-04-28 08:13:49, -PP (67%) import numpy as np def f1(v): # v: 1-D numpy array # for i in range(v.shape[0]): # if v[i] != i: return False # return True if np.all(v != v[:]) : return False return True def f2(u, v): # u and v are 1-D numpy array of equal size # n = u.shape[0] # return np.array([u[i]+v[n-i-1] for i in range(n)]) return u + v[::-1] def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] # A = [] # for i in range(M.shape[0]): # a = [] # for j in range(M.shape[1]): # a.append(M[i,j] * v[j]) # A.append(a) # return np.array(A) return M * v #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0202, 2022-04-28 08:14:14, -PP (67%) import numpy as np def f1(v): # v: 1-D numpy array # for i in range(v.shape[0]): # if v[i] != i: return False # return True if np.all(v != v[:]) : return False else: return True def f2(u, v): # u and v are 1-D numpy array of equal size # n = u.shape[0] # return np.array([u[i]+v[n-i-1] for i in range(n)]) return u + v[::-1] def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] # A = [] # for i in range(M.shape[0]): # a = [] # for j in range(M.shape[1]): # a.append(M[i,j] * v[j]) # A.append(a) # return np.array(A) return M * v #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0203, 2022-04-28 08:14:30, -PP (67%) import numpy as np def f1(v): # v: 1-D numpy array # for i in range(v.shape[0]): # if v[i] != i: return False # return True if np.all(v != v[:]) : return False else: return True def f2(u, v): # u and v are 1-D numpy array of equal size # n = u.shape[0] # return np.array([u[i]+v[n-i-1] for i in range(n)]) return u + v[::-1] def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] # A = [] # for i in range(M.shape[0]): # a = [] # for j in range(M.shape[1]): # a.append(M[i,j] * v[j]) # A.append(a) # return np.array(A) return M * v #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0204, 2022-04-28 08:16:36, -PP (67%) import numpy as np def f1(v): # v: 1-D numpy array # for i in range(v.shape[0]): # if v[i] != i: return False # return True if np.all(v == np.arange(v.shape[0])) : return False return True def f2(u, v): # u and v are 1-D numpy array of equal size # n = u.shape[0] # return np.array([u[i]+v[n-i-1] for i in range(n)]) return u + v[::-1] def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] # A = [] # for i in range(M.shape[0]): # a = [] # for j in range(M.shape[1]): # a.append(M[i,j] * v[j]) # A.append(a) # return np.array(A) return M * v #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0205, 2022-04-28 08:16:52, PPP (100%) import numpy as np def f1(v): # v: 1-D numpy array # for i in range(v.shape[0]): # if v[i] != i: return False # return True if np.all(v == np.arange(v.shape[0])) : return True return False def f2(u, v): # u and v are 1-D numpy array of equal size # n = u.shape[0] # return np.array([u[i]+v[n-i-1] for i in range(n)]) return u + v[::-1] def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] # A = [] # for i in range(M.shape[0]): # a = [] # for j in range(M.shape[1]): # a.append(M[i,j] * v[j]) # A.append(a) # return np.array(A) return M * v #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) |
# 0206, 2022-04-28 08:05:25, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
'''for i in range(v.shape[0]):
if v[i] != i: return False
return True'''
a = (v == np.arange(0,v.shape[0]))
return True *
| # 0207, 2022-04-28 08:11:24, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
'''for i in range(v.shape[0]):
if v[i] != i: return False
return True'''
a = (v == np.arange(0,v.shape[0]))
b = (v == v)
c = a * b
if np.sum(c) == v.shape[0] :
return True
else :
return False
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0208, 2022-04-28 08:13:40, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
'''for i in range(v.shape[0]):
if v[i] != i: return False
return True'''
a = (v == np.arange(0,v.shape[0]))
b = (v == v)
c = a * b
if np.sum(c) == v.shape[0] :
return True
else :
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
'''n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])'''
return u + (v[-2::-1])
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0209, 2022-04-28 08:14:34, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
'''for i in range(v.shape[0]):
if v[i] != i: return False
return True'''
a = (v == np.arange(0,v.shape[0]))
b = (v == v)
c = a * b
if np.sum(c) == v.shape[0] :
return True
else :
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
'''n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])'''
return u + (v[::-1])
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0210, 2022-04-28 08:15:23, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
'''for i in range(v.shape[0]):
if v[i] != i: return False
return True'''
a = (v == np.arange(0,v.shape[0]))
b = (v == v)
c = a * b
if np.sum(c) == v.shape[0] :
return True
else :
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
'''n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])'''
return u + (v[::-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
'''A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)'''
return M * v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0211, 2022-04-28 08:06:22, Pxx (33%)
import numpy as np
def f1(v):
check = check=np.arange(v.shape[0])
if np.sum(check==v) == v.shape[0]:
return True
else:
return False
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0212, 2022-04-28 08:09:57, compilation error (0%)
import numpy as np
def f1(v):
check = check=np.arange(v.shape[0])
if np.sum(check==v) == v.shape[0]:
return True
else:
return False
def f2(u, v):
u=[::-1]
return u+v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0213, 2022-04-28 08:10:22, P-x (33%)
import numpy as np
def f1(v):
check = check=np.arange(v.shape[0])
if np.sum(check==v) == v.shape[0]:
return True
else:
return False
def f2(u, v):
u=u[::-1]
return u+v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0214, 2022-04-28 08:11:42, PPx (67%)
import numpy as np
def f1(v):
check = check=np.arange(v.shape[0])
if np.sum(check==v) == v.shape[0]:
return True
else:
return False
def f2(u, v):
u=u[::-1]
return (u+v)[::-1]
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0215, 2022-04-28 08:14:57, PPP (100%)
import numpy as np
def f1(v):
check = check=np.arange(v.shape[0])
if np.sum(check==v) == v.shape[0]:
return True
else:
return False
def f2(u, v):
u=u[::-1]
return (u+v)[::-1]
def f3(M, v):
return v*M
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0216, 2022-04-28 08:03:56, xxx (0%) prinnt(f) | # 0217, 2022-04-28 08:07:11, Pxx (33%) import numpy as np def f1(v): # v: 1-D numpy array a = np.arange(v.shape[0]) return (v == a).all() #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0218, 2022-04-28 08:10:40, PPx (67%) import numpy as np def f1(v): # v: 1-D numpy array a = np.arange(v.shape[0]) return (v == a).all() def f2(u, v): # u and v are 1-D numpy array of equal size return u + v[::-1] #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0219, 2022-04-28 08:12:56, PPx (67%) import numpy as np def f1(v): # v: 1-D numpy array a = np.arange(v.shape[0]) return (v == a).all() def f2(u, v): # u and v are 1-D numpy array of equal size return u + v[::-1] #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0220, 2022-04-28 08:14:24, PPP (100%) import numpy as np def f1(v): # v: 1-D numpy array a = np.arange(v.shape[0]) return (v == a).all() def f2(u, v): # u and v are 1-D numpy array of equal size return u + v[::-1] def f3(M,v): return M*v #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) |
# 0221, 2022-04-28 08:04:37, -xx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
ind = np.arange(0,v.shape[0])
return v != ind
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0222, 2022-04-28 08:05:52, -xx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
ind = np.arange(0,v.shape[0])
return v == ind
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0223, 2022-04-28 08:07:55, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
ind = np.arange(0,v.shape[0])
if np.sum(v == ind) != v.shape[0]:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0224, 2022-04-28 08:10:41, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
ind = np.arange(0,v.shape[0])
if np.sum(v == ind) != v.shape[0]:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
i = np.arange(0,n)
return u[i]+v[n-i-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0225, 2022-04-28 08:12:46, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
ind = np.arange(0,v.shape[0])
if np.sum(v == ind) != v.shape[0]:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
i = np.arange(0,n)
return u[i]+v[n-i-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0226, 2022-04-28 08:08:22, compilation error (0%)
import numpy as np
def f1(v):
a = np.arange((v.shape[0])
d = a == v
if np.sum(d) != v.shape[0] : return False
return True
for k in range(int(input())):
exec(input().strip())
| # 0227, 2022-04-28 08:09:53, compilation error (0%)
import numpy as np
def f1(v):
a = np.arange((v.shape[0])
d = a == v
if np.sum(d) != v.shape[0] : return False
return True
for k in range(int(input())):
exec(input().strip())
| # 0228, 2022-04-28 08:11:47, Pxx (33%)
import numpy as np
def f1(v):
a = np.arange(v.shape[0])
d = a == v
if np.sum(d) != v.shape[0] : return False
return True
for k in range(int(input())):
exec(input().strip())
| # 0229, 2022-04-28 08:13:23, PPx (67%)
import numpy as np
def f1(v):
a = np.arange(v.shape[0])
d = a == v
if np.sum(d) != v.shape[0] : return False
return True
def f2(u, v):
ans = u + v[::-1]
return ans
for k in range(int(input())):
exec(input().strip())
| # 0230, 2022-04-28 08:15:16, PPP (100%)
import numpy as np
def f1(v):
a = np.arange(v.shape[0])
d = a == v
if np.sum(d) != v.shape[0] : return False
return True
def f2(u, v):
ans = u + v[::-1]
return ans
def f3(M, v):
return M*v
for k in range(int(input())):
exec(input().strip())
|
# 0231, 2022-04-28 08:12:11, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
ref = np.arange(len(f1))
checks = ref != f1
if np.sum(checks) != 0:
return False
else:
return True
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0232, 2022-04-28 08:12:47, -xx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
ref = np.arange(len(v))
checks = ref != f1
if np.sum(checks) != 0:
return False
else:
return True
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0233, 2022-04-28 08:16:37, Pxx (33%)
import numpy as np
def f1(v):
check = check=np.arange(v.shape[0])
if np.sum(check==v) == v.shape[0]:
return True
else:
return False
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0234, 2022-04-28 08:16:59, PPx (67%)
import numpy as np
def f1(v):
check = check=np.arange(v.shape[0])
if np.sum(check==v) == v.shape[0]:
return True
else:
return False
def f2(u, v):
u=u[::-1]
return (u+v)[::-1]
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0235, 2022-04-28 08:17:17, PPP (100%)
import numpy as np
def f1(v):
check = check=np.arange(v.shape[0])
if np.sum(check==v) == v.shape[0]:
return True
else:
return False
def f2(u, v):
u=u[::-1]
return (u+v)[::-1]
def f3(M, v):
return v*M
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0236, 2022-04-28 08:11:19, --- (0%)
import numpy as np
def f1(v):
a = np.arange(v.shape[0])
if np.sum(v == a) == v.shape[0]:
return True
else:
return False
def f2(u, v):
n = u.shape[0]
return np.array(u[0::] + v[n-1::-1])
def f3(M, v):
o = M*v
return o.reshape(M.shape[0]*M.shape[1])
| # 0237, 2022-04-28 08:12:01, --- (0%)
import numpy as np
def f1(v):
a = np.arange(v.shape[0])
if np.sum(v == a) == v.shape[0]:
return True
else:
return False
def f2(u, v):
n = u.shape[0]
return np.array(u[0::] + v[n-1::-1])
def f3(M, v):
o = M*v
return o.reshape(M.shape[0]*M.shape[1])
exec(input().strip())
| # 0238, 2022-04-28 08:13:37, PP- (67%)
import numpy as np
def f1(v):
a = np.arange(v.shape[0])
if np.sum(v == a) == v.shape[0]:
return True
else:
return False
def f2(u, v):
n = u.shape[0]
return np.array(u[0::] + v[n-1::-1])
def f3(M, v):
o = M*v
return o.reshape(M.shape[0]*M.shape[1])
for k in range(int(input())):
exec(input().strip())
| # 0239, 2022-04-28 08:14:43, PPP (100%)
import numpy as np
def f1(v):
a = np.arange(v.shape[0])
if np.sum(v == a) == v.shape[0]:
return True
else:
return False
def f2(u, v):
n = u.shape[0]
return np.array(u[0::] + v[n-1::-1])
def f3(M, v):
o = M*v
return o
for k in range(int(input())):
exec(input().strip())
|
# 0240, 2022-04-28 08:06:37, P-- (33%)
import numpy as np
def f1(v):
index = np.arange(v.shape[0])
check = v == index
return np.sum(check) == len(v)
def f2(u, v):
new_v = v[::-1]
total = u + v
return total
def f3(M, v):
return M.dot(v)
for k in range(int(input())):
exec(input().strip())
| # 0241, 2022-04-28 08:06:55, PP- (67%)
import numpy as np
def f1(v):
index = np.arange(v.shape[0])
check = v == index
return np.sum(check) == len(v)
def f2(u, v):
new_v = v[::-1]
total = u + new_v
return total
def f3(M, v):
return M.dot(v)
for k in range(int(input())):
exec(input().strip())
| # 0242, 2022-04-28 08:10:58, PPx (67%)
import numpy as np
def f1(v):
index = np.arange(v.shape[0])
check = v == index
return np.sum(check) == len(v)
def f2(u, v):
new_v = v[::-1]
total = u + new_v
return total
def f3(M, v):
return M * v.reshape((len(v), 1))
for k in range(int(input())):
exec(input().strip())
| # 0243, 2022-04-28 08:13:22, PPP (100%)
import numpy as np
def f1(v):
index = np.arange(v.shape[0])
check = v == index
return np.sum(check) == len(v)
def f2(u, v):
new_v = v[::-1]
total = u + new_v
return total
def f3(M, v):
return M * v
for k in range(int(input())):
exec(input().strip())
|
# 0244, 2022-04-28 08:08:25, Px- (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(v.shape[0])
if list(v) != list(a):
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M.dot(v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0245, 2022-04-28 08:12:11, PxP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(v.shape[0])
if list(v) != list(a):
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return v*M
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0246, 2022-04-28 08:13:38, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(v.shape[0])
if list(v) != list(a):
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u+v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return v*M
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0247, 2022-04-28 08:14:45, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(v.shape[0])
if list(v) != list(a):
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u+v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return v*M
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0248, 2022-04-28 08:08:26, -Px (33%)
import numpy as np
def f1(v):
d = v == np.arange(v.shape[0])
if True in d:
return False
else:
return True
def f2(u, v):
return np.array(u+v[::-1])
for k in range(int(input())):
exec(input().strip())
| # 0249, 2022-04-28 08:12:48, -Px (33%)
import numpy as np
def f1(v):
d = v == np.arange(v.shape[0])
if True in d:
return True
else:
return False
def f2(u, v):
return np.array(u+v[::-1])
for k in range(int(input())):
exec(input().strip())
| # 0250, 2022-04-28 08:13:44, PPx (67%)
import numpy as np
def f1(v):
d = v == np.arange(v.shape[0])
if False in d:
return False
else:
return True
def f2(u, v):
return np.array(u+v[::-1])
for k in range(int(input())):
exec(input().strip())
| # 0251, 2022-04-28 08:14:53, PPP (100%)
import numpy as np
def f1(v):
d = v == np.arange(v.shape[0])
if False in d:
return False
else:
return True
def f2(u, v):
return np.array(u+v[::-1])
def f3(M, v):
return M[:,:]*v[::]
for k in range(int(input())):
exec(input().strip())
|
# 0252, 2022-04-28 08:06:03, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return np.sum(np.arange(v.shape[0])!=v)!=0
for i in range(v.shape[0]):
if v[i] != i: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u[:]+v[::-1]
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M[:]*v
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0253, 2022-04-28 08:06:19, -PP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return np.sum(np.arange(v.shape[0])!=v)!=0
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u[:]+v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M[:]*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0254, 2022-04-28 08:06:42, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return np.sum(np.arange(v.shape[0])!=v)0=0
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u[:]+v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M[:]*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0255, 2022-04-28 08:06:47, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return np.sum(np.arange(v.shape[0])!=v)==0
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u[:]+v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M[:]*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0256, 2022-04-28 08:05:57, --- (0%)
import numpy as np
def f1(v):
return np.sum(v == np.arange(0,v.shape[0])) == v.shape[0]
def f2(u, v):
return u + v[::-1]
def f3(M, v):
return np.dot(M,v)
| # 0257, 2022-04-28 08:06:24, PP- (67%)
import numpy as np
def f1(v):
return np.sum(v == np.arange(0,v.shape[0])) == v.shape[0]
def f2(u, v):
return u + v[::-1]
def f3(M, v):
return np.dot(M,v)
for k in range(int(input())):
exec(input().strip())
| # 0258, 2022-04-28 08:06:33, PP- (67%)
import numpy as np
def f1(v):
return np.sum(v == np.arange(0,v.shape[0])) == v.shape[0]
def f2(u, v):
return u + v[::-1]
def f3(M, v):
return np.dot(M,v)
for k in range(int(input())):
exec(input().strip())
| # 0259, 2022-04-28 08:09:36, PPP (100%)
import numpy as np
def f1(v):
return np.sum(v == np.arange(0,v.shape[0])) == v.shape[0]
def f2(u, v):
return u + v[::-1]
def f3(M, v):
return M*v
for k in range(int(input())):
exec(input().strip())
|
# 0260, 2022-04-28 08:05:49, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
#for i in range(v.shape[0]):
# if v[i] != i: return False
#return True
r = np.arange(v.shape[0])
co = v[v==r]
if len(co)==v:
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0261, 2022-04-28 08:10:39, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
#for i in range(v.shape[0]):
# if v[i] != i: return False
#return True
r = np.arange(v.shape[0])
co = v[v[r]==r[r]]
if len(co)==len(v):
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
r = n[::]+n[::-1]
return r
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0262, 2022-04-28 08:14:48, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
#for i in range(v.shape[0]):
# if v[i] != i: return False
#return True
r = np.arange(v.shape[0])
co = v[v[r]==r[r]]
if len(co)==len(v):
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
r = u[::]+v[::-1]
return r
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
#A = []
#for i in range(M.shape[0]):
# a = []
# for j in range(M.shape[1]):
# a.append(M[i,j] * v[j])
# A.append(a)
S = M*v
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0263, 2022-04-28 08:15:28, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
#for i in range(v.shape[0]):
# if v[i] != i: return False
#return True
r = np.arange(v.shape[0])
co = v[v[r]==r[r]]
if len(co)==len(v):
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
r = u[::]+v[::-1]
return r
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
#A = []
#for i in range(M.shape[0]):
# a = []
# for j in range(M.shape[1]):
# a.append(M[i,j] * v[j])
# A.append(a)
S = M*v
return S
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0264, 2022-04-28 08:08:24, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(v.shape[0])
check = np.sum(pos != v)
return check==0
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
rv = v[::-1]
z = np.zeros(arange(u.shape[0]))
z += rv+u
return z
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0265, 2022-04-28 08:10:57, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(v.shape[0])
check = np.sum(pos != v)
return check==0
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
rv = v[::-1]
z = np.zeros(np.arange(u.shape[0]))
z += rv+u
return z
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0266, 2022-04-28 08:12:20, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(v.shape[0])
check = np.sum(pos != v)
return check==0
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
rv = v[::-1]
return rv + u
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0267, 2022-04-28 08:13:25, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(v.shape[0])
check = np.sum(pos != v)
return check==0
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
rv = v[::-1]
return rv + u
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0268, 2022-04-28 08:09:01, -Px (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i = np.arange(v.shape[0])
return v==i
def f2(u, v):
# u and v are 1-D numpy array of equal size
#u = np.arange(0,10,1)
#v = np.arange(10,20,1)
return np.array(u+v[::-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0269, 2022-04-28 08:10:04, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if all(v == np.arange(len(v))): return True
else: return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
#u = np.arange(0,10,1)
#v = np.arange(10,20,1)
return np.array(u+v[::-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0270, 2022-04-28 08:13:13, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return all(v == np.arange(len(v)))
def f2(u, v):
# u and v are 1-D numpy array of equal size
#u = np.arange(0,10,1)
#v = np.arange(10,20,1)
return np.array(u+v[::-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0271, 2022-04-28 08:14:25, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return all(v == np.arange(len(v)))
def f2(u, v):
# u and v are 1-D numpy array of equal size
#u = np.arange(0,10,1)
#v = np.arange(10,20,1)
return np.array(u+v[::-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0272, 2022-04-28 08:13:52, -PP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
# for i in range(v.shape[0]):
# if v[i] != i: return False
# return True
idx = np.arange(v.shape[0])
cmp = v!=idx
return np.min(cmp)
def f2(u, v):
# u and v are 1-D numpy array of equal size
# blank = np.zeros_like(u,int)
n = u.shape[0]
# return np.array([u[i]+v[n-i-1] for i in range(n)])
idx = np.arange(0,n)
return u[idx]+v[n-1-idx]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
# A = []
# for i in range(M.shape[0]):
# a = []
# for j in range(M.shape[1]):
# a.append(M[i,j] * v[j])
# A.append(a)
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0273, 2022-04-28 08:15:52, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
# for i in range(v.shape[0]):
# if v[i] != i: return False
# return True
idx = np.arange(v.shape[0])
if np.sum(v==idx) != v.shape[0]
return Fales
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
# blank = np.zeros_like(u,int)
n = u.shape[0]
# return np.array([u[i]+v[n-i-1] for i in range(n)])
idx = np.arange(0,n)
return u[idx]+v[n-1-idx]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
# A = []
# for i in range(M.shape[0]):
# a = []
# for j in range(M.shape[1]):
# a.append(M[i,j] * v[j])
# A.append(a)
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0274, 2022-04-28 08:16:35, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
# for i in range(v.shape[0]):
# if v[i] != i: return False
# return True
idx = np.arange(v.shape[0])
if np.sum(v==idx) != v.shape[0]
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
# blank = np.zeros_like(u,int)
n = u.shape[0]
# return np.array([u[i]+v[n-i-1] for i in range(n)])
idx = np.arange(0,n)
return u[idx]+v[n-1-idx]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
# A = []
# for i in range(M.shape[0]):
# a = []
# for j in range(M.shape[1]):
# a.append(M[i,j] * v[j])
# A.append(a)
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0275, 2022-04-28 08:16:47, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
# for i in range(v.shape[0]):
# if v[i] != i: return False
# return True
idx = np.arange(v.shape[0])
if np.sum(v==idx) != v.shape[0]:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
# blank = np.zeros_like(u,int)
n = u.shape[0]
# return np.array([u[i]+v[n-i-1] for i in range(n)])
idx = np.arange(0,n)
return u[idx]+v[n-1-idx]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
# A = []
# for i in range(M.shape[0]):
# a = []
# for j in range(M.shape[1]):
# a.append(M[i,j] * v[j])
# A.append(a)
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0276, 2022-04-28 08:08:24, xPP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
number = np.arange(v.shape[o])
if np.sum(v[number] != number) == 0 :return true
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0277, 2022-04-28 08:09:13, xPP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
number = np.arange(v.shape[0])
if np.sum(v[number] != number) == 0 :return true
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0278, 2022-04-28 08:09:30, xPP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
number = np.arange(v.shape[0])
if np.sum(v[number] != number) != 0 :return true
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0279, 2022-04-28 08:11:04, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return np.sum(v != np.arange(v.shape[0])) == 0
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0280, 2022-04-28 08:08:17, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i = np.arange(v.shape[0])
c = sum(v != i)
if c == 0:
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
i = np.arange(0,n)
j = -i+n-1
return u[i] + v[j]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.dot(v,M)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0281, 2022-04-28 08:11:37, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i = np.arange(v.shape[0])
c = sum(v != i)
if c == 0:
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
i = np.arange(0,n)
j = -i+n-1
return u[i] + v[j]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
a = M * v
return a
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0282, 2022-04-28 08:12:04, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i = np.arange(v.shape[0])
c = sum(v != i)
if c == 0:
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
i = np.arange(0,n)
j = -i+n-1
return u[i] + v[j]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0283, 2022-04-28 08:06:23, -PP (67%) import numpy as np def f1(v): n = v.shape[0] N = np.arange(n) return (v==N) def f2(u, v): # u and v are 1-D numpy array of equal size n = u.shape[0] newv = v[: : -1] return u+newv def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] zero = np.zeros(M.shape,int) v = v+zero return v*M #A = [] #for i in range(M.shape[0]): #a = [] #for j in range(M.shape[1]): #a.append(M[i,j] * v[j]) #A.append(a) #return np.array(A) #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0284, 2022-04-28 08:08:03, PPP (100%) import numpy as np def f1(v): n = v.shape[0] N = np.arange(n) check = v-N check = abs(check) sumcheck = np.sum(check) return (sumcheck == 0) def f2(u, v): # u and v are 1-D numpy array of equal size n = u.shape[0] newv = v[: : -1] return u+newv def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] zero = np.zeros(M.shape,int) v = v+zero return v*M #A = [] #for i in range(M.shape[0]): #a = [] #for j in range(M.shape[1]): #a.append(M[i,j] * v[j]) #A.append(a) #return np.array(A) #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0285, 2022-04-28 08:09:33, PPP (100%) import numpy as np def f1(v): n = v.shape[0] N = np.arange(n) check = v-N check = abs(check) sumcheck = np.sum(check) return (sumcheck == 0) def f2(u, v): # u and v are 1-D numpy array of equal size n = u.shape[0] newv = v[: : -1] return u+newv def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] zero = np.zeros(M.shape,int) v = v+zero return v*M #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) |
# 0286, 2022-04-28 08:10:07, P-P (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return np.sum(v == np.arange(0, v.shape[0])) == v.shape[0]
def f2(u, v):
# u and v are 1-D numpy array of equal size
# u = [1, 2, 3, 4, 5]
# v = [6, 7, 8, 9, 10]
a = v[::-1]
b = np.zeros_like(v)
b[:-1] = a[1:]
b[-1] = a[0]
return u + b
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M * v.reshape((1, v.shape[0]))
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0287, 2022-04-28 08:11:46, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return np.sum(v == np.arange(0, v.shape[0])) == v.shape[0]
def f2(u, v):
# u and v are 1-D numpy array of equal size
# u = [1, 2, 3, 4, 5]
# v = [6, 7, 8, 9, 10]
a = v[::-1]
b = np.zeros_like(v)
b[:-1] = a[1:]
b[-1] = a[0]
return u + b
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M * v.reshape((1, v.shape[0]))
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())import numpy as np
def f1(v):
# v: 1-D numpy array
return np.sum(v == np.arange(0, v.shape[0])) == v.shape[0]
def f2(u, v):
# u and v are 1-D numpy array of equal size
# u = [1, 2, 3, 4, 5]
# v = [6, 7, 8, 9, 10]
# a = v[::-1]
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M * v.reshape((1, v.shape[0]))
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0288, 2022-04-28 08:12:35, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return np.sum(v == np.arange(0, v.shape[0])) == v.shape[0]
def f2(u, v):
# u and v are 1-D numpy array of equal size
# u = [1, 2, 3, 4, 5]
# v = [6, 7, 8, 9, 10]
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M * v.reshape((1, v.shape[0]))
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0289, 2022-04-28 08:10:49, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x=np.arange(v.shape[0])
if np.sum(v!=x) != 0:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u+v[::-1]
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0290, 2022-04-28 08:15:19, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x=np.arange(v.shape[0])
if np.sum(v!=x) != 0:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u+v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]#colเท่า
return v.reshape((1,len(v)))*M
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0291, 2022-04-28 08:15:41, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x=np.arange(v.shape[0])
if np.sum(v!=x) != 0:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u+v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]#colเท่า
return v.reshape((1,v.shape[0]))*M
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0292, 2022-04-28 08:10:25, xPP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
r = np.arange(np.shape((v)[0]))
return np.sum(v != r) == 0
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M * v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0293, 2022-04-28 08:11:47, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
r = np.arange(v.shape[0]))
return np.sum(v != r) == 0
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M * v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0294, 2022-04-28 08:12:03, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
r = np.arange(v.shape[0])
return np.sum(v != r) == 0
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M * v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0295, 2022-04-28 08:05:53, PP- (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i = np.arange(v.shape[0])
if np.sum(i != v) > 0 :
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array[1,2],[3,4]
# v: 1-D numpy array [5,6]
# note: v.shape[0] equals to M.shape[1]
return np.dot( M , v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0296, 2022-04-28 08:07:46, PP- (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i = np.arange(v.shape[0])
if np.sum(i != v) > 0 :
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array[1,2],[3,4]
# v: 1-D numpy array [5,6]
# note: v.shape[0] equals to M.shape[1]
return np.dot( M , v).T
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0297, 2022-04-28 08:10:17, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i = np.arange(v.shape[0])
if np.sum(i != v) > 0 :
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array[1,2],[3,4]
# v: 1-D numpy array [5,6]
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0298, 2022-04-28 08:08:06, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
seq = np.arange(v.shape[0])
if np.sum(v != seq) > 0:
return False
return True
'''
for i in range(v.shape[0]):
if v[i] != i: return False
return True
'''
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0299, 2022-04-28 08:14:16, P-P (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
seq = np.arange(v.shape[0])
if np.sum(v != seq) > 0:
return False
return True
'''
for i in range(v.shape[0]):
if v[i] != i: return False
return True
'''
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
seq = np.arange(n)
return u[seq] + v[seq-1]
#return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
'''
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
'''
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0300, 2022-04-28 08:15:01, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
seq = np.arange(v.shape[0])
if np.sum(v != seq) > 0:
return False
return True
'''
for i in range(v.shape[0]):
if v[i] != i: return False
return True
'''
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
seq = np.arange(n)
return u[seq] + v[n-seq-1]
#return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
'''
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
'''
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0301, 2022-04-28 08:04:32, -PP (67%)
import numpy as np
def f1(v):
s = np.arange(0,v.shape[0],1)
return v[v!=s]
def f2(u,v):
s = v[::-1]
return np.array(u+s)
def f3(M,v):
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0302, 2022-04-28 08:07:27, -PP (67%)
import numpy as np
def f1(v):
s = np.arange(0,v.shape[0],1)
return False in (v!=s)
def f2(u,v):
s = v[::-1]
return np.array(u+s)
def f3(M,v):
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0303, 2022-04-28 08:08:26, PPP (100%)
import numpy as np
def f1(v):
s = np.arange(0,v.shape[0],1)
if True in (v!=s):return False
return True
def f2(u,v):
s = v[::-1]
return np.array(u+s)
def f3(M,v):
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0304, 2022-04-28 08:11:50, -PP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x = np.arange(v.shape[0])
y = np.array(x != v)
if False in x:
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0] #3
x = u[::] + v[::-1]
return x
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
x = M * v
return x
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0305, 2022-04-28 08:13:46, -PP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x = np.arange(v.shape[0])
y = np.array(x == v)
if False in x:
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0] #3
x = u[::] + v[::-1]
return x
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
x = M * v
return x
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0306, 2022-04-28 08:14:07, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x = np.arange(v.shape[0])
y = np.array(x == v)
if False in y:
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0] #3
x = u[::] + v[::-1]
return x
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
x = M * v
return x
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0307, 2022-04-28 08:09:04, -Px (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(len(v))
ch = pos[v[v==pos]]
if False in ch:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u[:] + v[n-1::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M[::] * v[j]
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0308, 2022-04-28 08:11:28, -PP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(len(v))
ch = pos[v[v==pos]]
if False in ch:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u[:] + v[n-1::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M[:,:] * v.reshape((1,len(v)))
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0309, 2022-04-28 08:13:55, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(len(v))
ch = v==pos
if False in ch:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u[:] + v[n-1::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M[:,:] * v.reshape((1,len(v)))
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0310, 2022-04-28 08:12:26, --- (0%) import numpy as np def f1(v): i = np.arange(0,v.shape[0]) c = v == i if False in c:return False return True def f2(u, v): return u + v[::-1] | # 0311, 2022-04-28 08:13:15, PPx (67%) import numpy as np def f1(v): i = np.arange(0,v.shape[0]) c = v == i if False in c:return False return True def f2(u, v): return u + v[::-1] for k in range(int(input())): exec(input().strip()) | # 0312, 2022-04-28 08:15:23, PPP (100%) import numpy as np def f1(v): i = np.arange(0,v.shape[0]) c = v == i if False in c:return False return True def f2(u, v): return u + v[::-1] def f3(M, v): return M*v for k in range(int(input())): exec(input().strip()) |
# 0313, 2022-04-28 08:11:41, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
c = np.arange(0,len(v))
if np.sum(v == c) == len(v):
return True
elif np.sum(v == c) != len(v):
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array(u[::]+v[n::-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0314, 2022-04-28 08:13:11, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
c = np.arange(0,len(v))
if np.sum(v == c) == len(v):
return True
elif np.sum(v == c) != len(v):
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array(u[::]+v[n::-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
pass
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0315, 2022-04-28 08:14:34, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
c = np.arange(0,len(v))
if np.sum(v == c) == len(v):
return True
elif np.sum(v == c) != len(v):
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array(u[::]+v[n::-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0316, 2022-04-28 08:07:47, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i = np.arange(v.shape[0])
if np.sum(v == i) == v.shape[0]:
return True
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
v_in = v[::-1]
return u + v_in
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0317, 2022-04-28 08:09:46, xPP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
#i = np.arange(v.shape[0])
#if np.sum(v == i) == v.shape[0]:
#return True
return np.sum(v == i) == v.shape[0]
def f2(u, v):
# u and v are 1-D numpy array of equal size
#n = u.shape[0]
#v_in = v[::-1]
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0318, 2022-04-28 08:10:30, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i = np.arange(v.shape[0])
return np.sum(v == i) == v.shape[0]
def f2(u, v):
# u and v are 1-D numpy array of equal size
#n = u.shape[0]
#v_in = v[::-1]
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0319, 2022-04-28 08:06:27, PPx (67%)
#grader quiz np
import numpy as np
def f1(v):
index = np.arange(v.shape[0])
v = v==index
if False in v:
return False
return True
def f2(u,v):
return u + v[::-1]
def f3(M, v):
return np.dot(v, M)
for k in range(int(input())):
exec(input().strip())
| # 0320, 2022-04-28 08:06:49, PP- (67%)
#grader quiz np
import numpy as np
def f1(v):
index = np.arange(v.shape[0])
v = v==index
if False in v:
return False
return True
def f2(u,v):
return u + v[::-1]
def f3(M, v):
return np.dot(M, v)
for k in range(int(input())):
exec(input().strip())
| # 0321, 2022-04-28 08:08:00, PPP (100%)
#grader quiz np
import numpy as np
def f1(v):
index = np.arange(v.shape[0])
v = v==index
if False in v:
return False
return True
def f2(u,v):
return u + v[::-1]
def f3(M, v):
return M * v
for k in range(int(input())):
exec(input().strip())
|
# 0322, 2022-04-28 08:04:55, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(v.shape[0])
b = v!=pos
c = np.sum(b)
return c == 0
for k in range(int(input())):
exec(input().strip())
| # 0323, 2022-04-28 08:10:03, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(v.shape[0])
b = v!=pos
c = np.sum(b)
return c == 0
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u[:]+v[::-1]
for k in range(int(input())):
exec(input().strip())
| # 0324, 2022-04-28 08:14:53, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(v.shape[0])
b = v!=pos
c = np.sum(b)
return c == 0
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u[:]+v[::-1]
def f3(M, v):
return M[:,:]*v[:]
for k in range(int(input())):
exec(input().strip())
|
# 0325, 2022-04-28 08:12:47, xPx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
for i in range(v.shape[0]):
if v[i] != i: return False
return True
def f2(u, v):
return u+v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0326, 2022-04-28 08:13:49, -PP (67%)
import numpy as np
def f1(v):
p = v.shape[0]
s = np.arange(p)
return np.all(v != s)
def f2(u, v):
return u + v[::-1]
def f3(M, v):
return M * v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0327, 2022-04-28 08:17:00, PPP (100%)
import numpy as np
def f1(v):
p = v.shape[0]
s = np.arange(p)
return np.all(v == s)
def f2(u, v):
return u + v[::-1]
def f3(M, v):
return M * v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0328, 2022-04-28 08:11:32, PPx (67%)
import numpy as np
def f1(v):
f1 = v == np.arange(v.shape[0])
if f1.sum() != v.shape[0]:
return False
else:
return True
def f2(u,v):
n = u.shape[0]
return u[:] + v[n-1::-1]
def f3(M,v):
pass
for k in range(int(input())):
exec(input().strip())
| # 0329, 2022-04-28 08:13:55, PPP (100%)
import numpy as np
def f1(v):
f1 = v == np.arange(v.shape[0])
if f1.sum() != v.shape[0]:
return False
else:
return True
def f2(u,v):
n = u.shape[0]
return u[:] + v[n-1::-1]
def f3(M,v):
A = []
x = M.shape[0]
y =M.shape[1]
return M[:x,:y] * v[:y]
for k in range(int(input())):
exec(input().strip())
|
# 0330, 2022-04-28 08:07:05, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
c = np.arange(v.shape[0])
d = np.sum(v != c )
if np.sum(d) > 0 : return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
i = np.arange(n)
return np.array(u[i]+v[n-i-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0331, 2022-04-28 08:09:28, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
c = np.arange(v.shape[0])
d = np.sum(v != c )
if np.sum(d) > 0 : return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
i = np.arange(n)
return np.array(u[i]+v[n-i-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = M*v
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0332, 2022-04-28 08:05:27, -PP (67%) import numpy as np def f1(v): # v: 1-D numpy array return def f2(u, v): # u and v are 1-D numpy array of equal size return u+v[::-1] def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] A = v.reshape((1,len(v))) return M*A #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0333, 2022-04-28 08:07:49, PPP (100%) import numpy as np def f1(v): # v: 1-D numpy array a = np.arange(len(v)) return np.sum(v!=a)==0 def f2(u, v): # u and v are 1-D numpy array of equal size return u+v[::-1] def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] A = v.reshape((1,len(v))) return M*A #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) |
# 0334, 2022-04-28 08:10:39, xPP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
# for i in range(v.shape[0]):
# if v[i] != i: return False
# return True
a = np.arrange(v.shape[0])
b = v == a
if np.sum(b)== np.sum(np.ones_like(b)):
return( True)
else:
return(False)
def f2(u, v):
# u and v are 1-D numpy array of equal size
# n = u.shape[0]
# return np.array([u[i]+v[n-i-1] for i in range(n)])
a = np.array(v)
b = v[::-1]
return(u+b)
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
# A = []
# for i in range(M.shape[0]):
# a = []
# for j in range(M.shape[1]):
# a.append(M[i,j] * v[j])
# A.append(a)
# return np.array(A)
a = np.array(v)
b = a.reshape((1,a.shape[0]))
c = M*b
return(c)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0335, 2022-04-28 08:14:12, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
# for i in range(v.shape[0]):
# if v[i] != i: return False
# return True
a = np.arange(v.shape[0])
b = v == a
if np.sum(b) == np.sum(np.ones_like(b)):
return(True)
else:
return(False)
def f2(u, v):
a = np.array(v)
b = v[::-1]
return(u+b)
def f3(M, v):
a = np.array(v)
b = a.reshape((1,a.shape[0]))
c = M*b
return(c)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0336, 2022-04-28 08:11:19, PPP (100%)
import numpy as np
def f1(v) :
r = np.arange(v.shape[0])
if np.sum( v!=r ) == 0 :
return True
return False
def f2(u, v):
return u + v[::-1]
def f3(M, v):
return M * (np.array(v))
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0337, 2022-04-28 08:13:41, PPP (100%)
import numpy as np
def f1(v) :
r = np.arange(v.shape[0])
if np.sum( v!=r ) == 0 :
return True
return False
def f2(u, v):
return u + v[::-1]
def f3(M, v):
return M * (np.array(v))
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0338, 2022-04-28 08:16:30, compilation error (0%)
import numpy as np
def f1(v):
s =v.shape[0]
return np.sum(v != np.arange(s)) == 0
def f2(u, v):
return u[::] + v[::-1]
def f3(M, v):
return M[::] * v[::]
# ----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip()
| # 0339, 2022-04-28 08:17:03, PPP (100%)
import numpy as np
def f1(v):
s =v.shape[0]
return np.sum(v != np.arange(s)) == 0
def f2(u, v):
return u[::] + v[::-1]
def f3(M, v):
return M[::] * v[::]
# ----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0340, 2022-04-28 08:09:10, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x=np.arange(v.shape[0])
return np.sum(v==x)==v.shape[0]
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u+v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
v=v.reshape((v.shape[0],-1))
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0341, 2022-04-28 08:11:00, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x=np.arange(v.shape[0])
return np.sum(v==x)==v.shape[0]
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u+v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0342, 2022-04-28 08:07:01, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(v.shape[0])
return np.sum(pos == v) == len(v)
def f2(u, v):
# u and v are 1-D numpy array of equal size
pos = np.arange(u.shape[0])
return u[pos] + v[u.shape[0] - pos - 1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0343, 2022-04-28 08:08:58, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(v.shape[0])
return np.sum(pos == v) == len(v)
def f2(u, v):
# u and v are 1-D numpy array of equal size
pos = np.arange(u.shape[0])
return u[pos] + v[u.shape[0] - pos - 1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M[:] * v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0344, 2022-04-28 08:13:28, PxP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
r = np.arange(0,v.shape[0])
if str(v) == str(r):
return True
else:
return False
#for i in range(v.shape[0]):
#if v[i] != i: return False
#return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
nn = n - np.arange(0,n)
nv = v[nn]
return u + nv
#return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M * v
#A = []
#for i in range(M.shape[0]):
#a = []
#for j in range(M.shape[1]):
#a.append(M[i,j] * v[j])
#A.append(a)
#return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0345, 2022-04-28 08:14:19, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
r = np.arange(0,v.shape[0])
if str(v) == str(r):
return True
else:
return False
#for i in range(v.shape[0]):
#if v[i] != i: return False
#return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
nn = n - np.arange(0,n) - 1
nv = v[nn]
return u + nv
#return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M * v
#A = []
#for i in range(M.shape[0]):
#a = []
#for j in range(M.shape[1]):
#a.append(M[i,j] * v[j])
#A.append(a)
#return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0346, 2022-04-28 08:10:17, -PP (67%)
import numpy as np
def f1(v):
a=np.arange(v.shape[0])
return a==v
def f2(u, v):
n = u.shape[0]
return u[::]+v[n-1::-1]
def f3(M, v):
return v*M
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0347, 2022-04-28 08:13:31, PPP (100%)
import numpy as np
def f1(v):
a=np.arange(v.shape[0])
if sum(a==v)==v.shape[0]:
return True
else:
return False
def f2(u, v):
n = u.shape[0]
return u[::]+v[n-1::-1]
def f3(M, v):
return v*M
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0348, 2022-04-28 08:04:05, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
d = np.arange(v.shape[0])
c = d == v
if np.sum(c) != c.shape[0] :
return False
return True
| # 0349, 2022-04-28 08:09:28, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
d = np.arange(v.shape[0])
c = d == v
if np.sum(c) != c.shape[0] :
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return v[::-1] + u
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M * v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0350, 2022-04-28 08:11:17, PPP (100%)
import numpy as np
def f1(v):
n = np.arange(v.shape[0])
if np.min(v==n)==0:
return False
return True
def f2(u, v):
n = np.arange(u.shape[0])
return u[n]+v[n[-1::-1]]
def f3(M, v):
return M*v
for k in range(int(input())):
exec(input().strip())
| # 0351, 2022-04-28 08:14:16, PPP (100%)
import numpy as np
def f1(v):
n = np.arange(v.shape[0])
if np.min(v==n)==0:
return False
return True
def f2(u, v):
n = np.arange(u.shape[0])
return u[n]+v[n[-1::-1]]
def f3(M, v):
return M*v
for k in range(int(input())):
exec(input().strip())
|
# 0352, 2022-04-28 08:14:16, PPP (100%)
import numpy as np
def f1(v):
check = np.arange(v.shape[0])
lo = v==check
if sum(lo) == len(v):
return True
else:
return False
def f2(u, v):
return u + v[::-1]
def f3(M,v):
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0353, 2022-04-28 08:14:38, PPP (100%)
import numpy as np
def f1(v):
check = np.arange(v.shape[0])
lo = v==check
if sum(lo) == len(v):
return True
else:
return False
def f2(u, v):
return u + v[::-1]
def f3(M,v):
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0354, 2022-04-28 08:10:48, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
v_row = v.shape[0]
a = np.arange(v_row)
b = np.sum(a != v)
return b == 0
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
v_back = v[::-1]
return u + v_back
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M * v
| # 0355, 2022-04-28 08:11:59, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
v_row = v.shape[0]
a = np.arange(v_row)
b = np.sum(a != v)
return b == 0
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
v_back = v[::-1]
return u + v_back
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M * v
for k in range(int(input())):
exec(input().strip())
|
# 0356, 2022-04-28 08:07:55, PP- (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x=np.arange(v.shape[0])
return np.sum(v!=x)==0
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u+v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.dot(M,v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0357, 2022-04-28 08:10:49, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x=np.arange(v.shape[0])
return np.sum(v!=x)==0
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u+v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0358, 2022-04-28 08:07:34, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(v.shape[0])
if np.sum(v - pos) != 0: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
for k in range(int(input())):
exec(input().strip())
| # 0359, 2022-04-28 08:09:27, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(v.shape[0])
if np.sum(v - pos != 0) != 0: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
for k in range(int(input())):
exec(input().strip())
|
# 0360, 2022-04-28 08:14:05, --- (0%)
import numpy as np
def f1(v):
a = np.arange(len(v))
if np.sum(v-a) != 0:
return False
else:
return True
def f2(u, v):
n = len(u)
s = u+v[::-1]
return s
def f3(M, v):
s = M*v
return s
| # 0361, 2022-04-28 08:14:27, PPP (100%)
import numpy as np
def f1(v):
a = np.arange(len(v))
if np.sum(v-a) != 0:
return False
else:
return True
def f2(u, v):
n = len(u)
s = u+v[::-1]
return s
def f3(M, v):
s = M*v
return s
for k in range(int(input())):
exec(input().strip())
|
# 0362, 2022-04-28 08:06:55, -PP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
n = v.shape[0]
a = np.arange(n)
return n == a
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
x = u + v[::-1]
return x
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
x= M*v
return x
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0363, 2022-04-28 08:10:27, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
n = v.shape[0]
a = np.arange(n)
return (v==a).sum() == v.shape[0]
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
x = u + v[::-1]
return x
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
x= M*v
return x
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0364, 2022-04-28 08:12:31, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
# for i in range(v.shape[0]):
# if v[i] != i: return False
# return True
compare = np.arange(0,len(v),1)
b = v[v!=compare]
c = np.sum(b)
if c>0 :
return False
return True
# a = np.array([0,1,2,3])
# print(f1(a))
def f2(u, v):
# u and v are 1-D numpy array of equal size 01234 01234 //03 12 21 30
# n = u.shape[0]
# return np.array([u[i]+v[n-i-1] for i in range(n)])
return u+v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0365, 2022-04-28 08:15:15, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
# for i in range(v.shape[0]):
# if v[i] != i: return False
# return True
compare = np.arange(0,len(v),1)
b = v[v!=compare]
c = np.sum(b)
if c>0 :
return False
return True
# a = np.array([0,1,2,3])
# print(f1(a))
def f2(u, v):
# u and v are 1-D numpy array of equal size 01234 01234 //03 12 21 30
# n = u.shape[0]
# return np.array([u[i]+v[n-i-1] for i in range(n)])
return u+v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
# A = []
# for i in range(M.shape[0]):
# a = []
# for j in range(M.shape[1]):
# a.append(M[i,j] * v[j])
# A.append(a)
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0366, 2022-04-28 08:12:16, PPx (67%)
import numpy as np
def f1(v):
a = np.arange(v.shape[0])
return np.array_equal(v, a)
def f2(u, v):
return np.array(u+v[::-1])
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0367, 2022-04-28 08:14:52, PPP (100%)
import numpy as np
def f1(v):
a = np.arange(v.shape[0])
return np.array_equal(v, a)
def f2(u, v):
return np.array(u+v[::-1])
def f3(M, v):
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0368, 2022-04-28 08:13:21, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(v.shape[0])
b = np.sum(a == v)
if b == v.shape[0]:
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
v = v[::-1]
return v + u
def f3(M, v):
pass
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0369, 2022-04-28 08:16:12, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(v.shape[0])
b = np.sum(a == v)
if b == v.shape[0]:
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
v = v[::-1]
return v + u
def f3(M, v):
return M * v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0370, 2022-04-28 08:09:30, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(v.shape[0])
if False in ((a-v) == 0):
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u + v[::-1]
#return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0371, 2022-04-28 08:12:54, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(v.shape[0])
if False in ((a-v) == 0):
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u + v[::-1]
#return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0372, 2022-04-28 08:10:35, PxP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
compare = np.arange(v.shape[0])
if np.sum(v==compare) == v.shape[0]:
return True
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
out=u[::,::]+v[::-1,::]
return out
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
out=M[::,::]*v[::]
return out
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0373, 2022-04-28 08:12:04, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
compare = np.arange(v.shape[0])
if np.sum(v==compare) == v.shape[0]:
return True
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
out=u[::]+v[::-1]
return out
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
out=M[::,::]*v[::]
return out
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0374, 2022-04-28 08:12:28, xx- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
r,c = v.shape
test = np.arange(r)
count = np.sum(r)*c
check = np.sum(v) == count
return check
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
vv= v[::-1, :]
return u + vv
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.dot(M,v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0375, 2022-04-28 08:14:57, PPP (100%)
import numpy as np
def f1(v):
f1 = v == np.arange(v.shape[0])
if f1.sum() != v.shape[0]:
return False
else:
return True
def f2(u,v):
n = u.shape[0]
return u[:] + v[n-1::-1]
def f3(M,v):
A = []
x = M.shape[0]
y =M.shape[1]
return M[:x,:y] * v[:y]
for k in range(int(input())):
exec(input().strip())
|
# 0376, 2022-04-28 08:11:37, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x = np.arange(v.shape[0])
y = np.sum(v != x)
return y == 0
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*V
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0377, 2022-04-28 08:12:23, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x = np.arange(v.shape[0])
y = np.sum(v != x)
return y == 0
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0378, 2022-04-28 08:06:05, PPP (100%)
import numpy as np
def f1(v):
m = np.arange(v.shape[0])
return np.sum(m==v) == v.shape[0]
def f2(u,v):
return u+v[::-1]
def f3(M,v):
return M*v
for k in range(int(input())):
exec(input().strip())
|
# 0379, 2022-04-28 08:09:18, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
check=np.arange(v.shape[0])
if (check==v).sum() == v.shape[0]:
return True
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u+v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0380, 2022-04-28 08:15:01, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i = np.arange(0,v.shape[0],1)
return np.sum(v-i) == 0
def f2(u, v):
# u and v are 1-D numpy array of equal size
v = v[::-1]
return u+v
def f3(M, v):
return M*v
for k in range(int(input())):
exec(input().strip())
|
# 0381, 2022-04-28 08:07:34, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
position=np.arange(v.shape[0])
if np.sum(v!=position)!=0:
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u+v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0382, 2022-04-28 08:14:08, PPP (100%)
import numpy as np
def f1(v):
A = v == np.arange(0, v.shape[0])
return np.sum(A) == v.shape[0]
def f2(u, v):
A = v[::-1]
return u + A
def f3(M, v):
return v.reshape((1, v.shape[0])) * M
for k in range(int(input())):
exec(input().strip())
|
# 0383, 2022-04-28 08:07:36, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
u = np.arange(v.shape[0])
if np.sum(u==v) == v.shape[0]:
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
return np.array(u + v[::-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.array(M*v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0384, 2022-04-28 08:07:44, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
hp = np.arange(v.shape[0])
s = np.sum(hp!=v)
if s != 0 : return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0] #0 3
v2 = v[::-1]
return u+v2
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0385, 2022-04-28 08:11:46, PPP (100%)
import numpy as np
def f1(v):
a = np.arange(v.shape[0])
if False in (a==v):
return False
else:
return True
def f2(u, v):
return u[::]+v[::-1]
def f3(M, v):
ans = M*v
return ans
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0386, 2022-04-28 08:12:45, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
r=np.arange(v.shape[0])
t= v==r
u= t==False
if np.sum(u) ==0:
return True
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
return np.array(u+v[::-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
r=v*M
return np.array(r)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0387, 2022-04-28 08:13:35, PPP (100%) import numpy as np def f1(v): # v: 1-D numpy array p = np.arange(v.shape[0]) return np.sum(p == v) == len(v) def f2(u, v): # u and v are 1-D numpy array of equal size p = np.arange(u.shape[0]) return u[p] + v[u.shape[0] - p -1] def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] return M[:] * v #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) |
# 0388, 2022-04-28 08:11:16, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
wow = np.arange(v.shape[0])
this = (v == wow )
final = False in this
final = not final
return final
def f2(u, v):
# u and v are 1-D numpy array of equal size
final = u + v[::-1]
return final
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M * v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0389, 2022-04-28 08:16:08, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return np.sum(np.arange(v.shape[0])==v) == v.shape[0]
def f2(u, v):
# u and v are 1-D numpy array of equal size
return v[::-1] + u
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M * v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0390, 2022-04-28 08:09:25, PPP (100%) import numpy as np def f1(v): return np.min(v == np.arange(v.shape[0])) def f2(u, v): return u + v[::-1] def f3(M, v): return M * v.reshape((1, v.shape[0])) #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) |
# 0391, 2022-04-28 08:12:13, PPP (100%) import numpy as np def f1(v): # v: 1-D numpy array return np.sum(np.arange(v.shape[0]) == v) == v.shape[0] def f2(u, v): # u and v are 1-D numpy array of equal size q = u + v[::-1] return q def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] return np.array(M*v) #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) |
# 0392, 2022-04-28 08:12:18, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
arange = np.arange(v.shape[0])
tf = np.sum(v==arange)
if len(v) == tf :
return True
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
rev = v[::-1]
show = u + rev
return show
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0393, 2022-04-28 08:14:09, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x = np.arange(v.shape[0])
if (x== v).min() ==0:
return False
else: return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u+v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M * v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0394, 2022-04-28 08:14:38, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if (np.arange(v.shape[0]) == v).min() == 0:
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u+v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return (M * v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0395, 2022-04-28 08:08:50, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(v.shape[0])
if np.sum(v==a) !=v.shape[0]: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u[:]+v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0396, 2022-04-28 08:12:08, PPP (100%)
import numpy as np
def f1(v):
tmp=np.arange(v.shape[0])
ans=np.sum(tmp-v)
if ans==0:
return True
else:
return False
def f2(u, v):
return u+v[::-1]
def f3(M, v):
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0397, 2022-04-28 08:11:35, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a=np.arange(v.shape[0])
if np.min(a==v)==0: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u+v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1] A = []
j=np.arange(v.shape[0])
return M * v[j]
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0398, 2022-04-28 08:11:50, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return np.min(np.arange(v.shape[0])== v)
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u[::] + v[-1::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0399, 2022-04-28 08:12:36, PPP (100%)
import numpy as np
def f1(v):
a = np.arange(v.shape[0])
b = v != a
c = b.sum()
if c == 0:
return True
else:
return False
def f2(u, v):
a = v[::-1]
b = u + a
return b
def f3(M, v):
a = M * v
return a
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0400, 2022-04-28 08:14:24, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
n = np.arange(0,v.shape[0])
a = n == v
if np.sum(a) == v.shape[0] :
return True
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
v = v[::-1]
return u+v
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M * v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0401, 2022-04-28 08:14:47, PPP (100%) # [64_2_PCG_12] 64_2_12_NumPy import numpy as np def f1(v): return np.sum(v == np.arange(v.shape[0])) == v.shape[0] def f2(u, v): n = u.shape[0] return u + v[v.shape[0]-1::-1] def f3(M, v): return v*M #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) |
# 0402, 2022-04-28 08:15:52, PPP (100%)
import numpy as np
def f1(v):
return np.sum(v != np.arange(v.shape[0])) == 0
def f2(u, v):
return u[:] + v[::-1]
def f3(M, v):
return M * v
# ----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0403, 2022-04-28 08:14:31, PPP (100%)
import numpy as np
def f1(v):
# v: 1-D numpy array
n = np.arange(len(v))
car = n[n == v]
if len(car) == len(v):
return True
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
revv=v[::-1]
return u + revv
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M * v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0404, 2022-04-28 08:05:47, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
check = np.arange(len(v))
check2 = check == v
if np.mean(check2) != 1:
return False
return True
for k in range(int(input())):
exec(input().strip())
| # 0405, 2022-04-28 08:08:08, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
check = np.arange(len(v))
check2 = check == v
if np.mean(check2) != 1:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
a = u + v[n-1,-1]
return a
for k in range(int(input())):
exec(input().strip())
| # 0406, 2022-04-28 08:08:23, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
check = np.arange(len(v))
check2 = check == v
if np.mean(check2) != 1:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
a = u + v[n-1,-1]
return a
for k in range(int(input())):
exec(input().strip())
| # 0407, 2022-04-28 08:09:21, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
check = np.arange(len(v))
check2 = check == v
if np.mean(check2) != 1:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
a = u[:len(n)] + v[n-1,-1]
return a
for k in range(int(input())):
exec(input().strip())
| # 0408, 2022-04-28 08:10:23, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
check = np.arange(len(v))
check2 = check == v
if np.mean(check2) != 1:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
a = u[:len(n)] + v[n-1,-2]
return a
for k in range(int(input())):
exec(input().strip())
| # 0409, 2022-04-28 08:10:32, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
check = np.arange(len(v))
check2 = check == v
if np.mean(check2) != 1:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
a = u[:len(n)] + v[n-1,-2]
return a
for k in range(int(input())):
exec(input().strip())
| # 0410, 2022-04-28 08:10:49, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
check = np.arange(len(v))
check2 = check == v
if np.mean(check2) != 1:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
a = u[:len(n)] + v[n-1,-2]
return a
for k in range(int(input())):
exec(input().strip())
| # 0411, 2022-04-28 08:15:15, Px- (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
check = np.arange(len(v))
check2 = check == v
if np.mean(check2) != 1:
return False
return True
'''def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
a = u[:len(n)] + v[n-1,-2]
return a'''
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M.dot(v)
for k in range(int(input())):
exec(input().strip())
| # 0412, 2022-04-28 08:15:23, Px- (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
check = np.arange(len(v))
check2 = check == v
if np.mean(check2) != 1:
return False
return True
'''def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
a = u[:len(n)] + v[n-1,-2]
return a'''
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M.dot(v)
for k in range(int(input())):
exec(input().strip())
| # 0413, 2022-04-28 08:16:53, P-- (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
check = np.arange(len(v))
check2 = check == v
if np.mean(check2) != 1:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
a = u[:n] + v[-1]
return a
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M.dot(v)
for k in range(int(input())):
exec(input().strip())
| # 0414, 2022-04-28 08:17:06, P-P (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
check = np.arange(len(v))
check2 = check == v
if np.mean(check2) != 1:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
a = u[:n] + v[-1]
return a
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
for k in range(int(input())):
exec(input().strip())
|
# 0415, 2022-04-28 08:04:30, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if v[v.shape[0]]!=i:
return False
return True
| # 0416, 2022-04-28 08:05:24, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if v[:,:v.shape[0]]!=i:
return False
return True
| # 0417, 2022-04-28 08:05:40, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if v[:v.shape[0]]!=i:
return False
return True
| # 0418, 2022-04-28 08:08:22, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if True in (v[:,:v.shape[0]]!=np.arange(v.shape[0])):
return False
return True
| # 0419, 2022-04-28 08:10:07, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if True in (v[:v.shape[0]]!=np.arange(v.shape[0])):
return False
return True
| # 0420, 2022-04-28 08:11:10, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if True in (v[:v.shape[0]]!=np.arange(v.shape[0])):
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u[:]+v[n-1::-1]
| # 0421, 2022-04-28 08:12:24, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if True in (v[:v.shape[0]]!=np.arange(v.shape[0])):
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u[:n]+v[(n-1)::-1]
| # 0422, 2022-04-28 08:12:51, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if True in (v[:v.shape[0]]!=np.arange(v.shape[0])):
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u[:n]+v[(n-1)::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0423, 2022-04-28 08:13:50, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if True in (v[:v.shape[0]]!=np.arange(v.shape[0])):
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u[:n]+v[(n-1)::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.dot(M,V)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0424, 2022-04-28 08:14:18, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if True in (v[:v.shape[0]]!=np.arange(v.shape[0])):
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u[:n]+v[(n-1)::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.dot(V,M)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0425, 2022-04-28 08:05:24, -xx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a=np.arange(v.shape[0])
z=(a==v)
if np.sum(z) !=0:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return #np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
#A = []
#for i in range(M.shape[0]):
#a = []
#for j in range(M.shape[1]):
#a.append(M[i,j] * v[j])
#A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0426, 2022-04-28 08:06:08, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a=np.arange(v.shape[0])
z=(a==v)
if np.sum(z) !=0:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return #np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
#A = []
#for i in range(M.shape[0]):
#a = []
#for j in range(M.shape[1]):
#a.append(M[i,j] * v[j])
#A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
exec(input().strip())
| # 0427, 2022-04-28 08:06:21, -xx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a=np.arange(v.shape[0])
z=(a==v)
if np.sum(z) !=0:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return #np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
#A = []
#for i in range(M.shape[0]):
#a = []
#for j in range(M.shape[1]):
#a.append(M[i,j] * v[j])
#A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0428, 2022-04-28 08:10:44, -Px (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a=np.arange(v.shape[0])
z=(a==v)
if np.sum(z) !=0:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
v2=v[::-1]
return np.array(u+v2)
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
#A = []
#for i in range(M.shape[0]):
#a = []
#for j in range(M.shape[1]):
#a.append(M[i,j] * v[j])
#A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0429, 2022-04-28 08:13:55, -Px (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a=np.arange(np.shape(v)[0])
z=(a==v)
if np.sum(z) !=0:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
v2=v[::-1]
return np.array(u+v2)
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
#A = []
#for i in range(M.shape[0]):
#a = []
#for j in range(M.shape[1]):
#a.append(M[i,j] * v[j])
#A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0430, 2022-04-28 08:14:37, -PP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a=np.arange(np.shape(v)[0])
z=(a==v)
if np.sum(z) !=0:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
v2=v[::-1]
return np.array(u+v2)
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
#A = []
#for i in range(M.shape[0]):
#a = []
#for j in range(M.shape[1]):
#a.append(M[i,j] * v[j])
#A.append(a)
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0431, 2022-04-28 08:15:46, -PP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a=np.arange(v.shape[0])
z=(a==v)
if np.sum(z) !=0:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
v2=v[::-1]
return np.array(u+v2)
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
#A = []
#for i in range(M.shape[0]):
#a = []
#for j in range(M.shape[1]):
#a.append(M[i,j] * v[j])
#A.append(a)
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0432, 2022-04-28 08:16:01, -PP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a=np.arange(v.shape[0])
z=a==v
if np.sum(z) !=0:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
v2=v[::-1]
return np.array(u+v2)
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
#A = []
#for i in range(M.shape[0]):
#a = []
#for j in range(M.shape[1]):
#a.append(M[i,j] * v[j])
#A.append(a)
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0433, 2022-04-28 08:16:19, -PP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a=np.arange(0,v.shape[0])
z=a==v
if np.sum(z) !=0:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
v2=v[::-1]
return np.array(u+v2)
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
#A = []
#for i in range(M.shape[0]):
#a = []
#for j in range(M.shape[1]):
#a.append(M[i,j] * v[j])
#A.append(a)
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0434, 2022-04-28 08:04:37, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
v = v.T
x = np.arange(v.shape[0])
if v != x:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0435, 2022-04-28 08:05:47, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x = np.arange(v.shape[0])
if v != x:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0436, 2022-04-28 08:07:35, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x = np.arange(v.shape[0])
z = v - x
if np.max(z) != 0:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0437, 2022-04-28 08:09:46, P-x (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x = np.arange(v.shape[0])
z = v - x
if np.max(z) != 0:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
x = np.arange(v.shape[0])
return np.array([u[x]+v[v.shape[0]-x-1]])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0438, 2022-04-28 08:11:12, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x = np.arange(v.shape[0])
z = v - x
if np.max(z) != 0:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
x = np.arange(v.shape[0])
U = u[x]
V = v[v.shape[0]-x-1]
return U+V
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0439, 2022-04-28 08:13:55, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x = np.arange(v.shape[0])
z = v - x
if np.max(z) != 0:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
x = np.arange(v.shape[0])
U = u[x]
V = v[v.shape[0]-x-1]
return U+V
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
x = np.arange(M.shape[1])
y = np.arange(M.shape[0])
return x*y
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0440, 2022-04-28 08:14:36, PP- (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x = np.arange(v.shape[0])
z = v - x
if np.max(z) != 0:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
x = np.arange(v.shape[0])
U = u[x]
V = v[v.shape[0]-x-1]
return U+V
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
x = np.arange(M.shape[1])
y = np.arange(v.shape[0])
return x*y
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0441, 2022-04-28 08:15:57, PP- (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x = np.arange(v.shape[0])
z = v - x
if np.max(z) != 0:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
x = np.arange(v.shape[0])
U = u[x]
V = v[v.shape[0]-x-1]
return U+V
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
x = np.arange(M.shape[1])
y = np.arange(v.shape[0])
y = y.reshape(1,v.shape[0])
return x*y
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0442, 2022-04-28 08:06:08, -xx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(v.shape[0])
return pos[pos==v]
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0443, 2022-04-28 08:07:46, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(v.shape[0])
if np.sum(pos==v) == len(v):
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0444, 2022-04-28 08:11:38, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(v.shape[0])
if np.sum(pos==v) == len(v):
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
pos = np.arange(v.shape[0])
if u[pos] + v[u.shape[0] - pos -1]:
return True
else:
return False
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0445, 2022-04-28 08:12:23, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(v.shape[0])
if np.sum(pos==v) == len(v):
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
pos = np.arange(v.shape[0])
if u[pos] + v[u.shape[0] - pos -1]:
return True
else:
return False
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
pass
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0446, 2022-04-28 08:14:15, PxP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(v.shape[0])
if np.sum(pos==v) == len(v):
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
pos = np.arange(v.shape[0])
if u[pos] + v[u.shape[0] - pos -1]:
return True
else:
return False
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M[:] * v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0447, 2022-04-28 08:14:55, PxP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(v.shape[0])
if np.sum(pos==v) == len(v):
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
pos = np.arange(v.shape[0])
if u[pos] + v[v.shape[0] - pos -1]:
return True
else:
return False
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M[:] * v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0448, 2022-04-28 08:15:41, PxP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(v.shape[0])
if np.sum(pos==v) == len(v):
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
pos = np.arange(u.shape[0])
if u[pos] + v[u.shape[0] - pos -1]:
return True
else:
return False
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M[:] * v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0449, 2022-04-28 08:17:03, PxP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(v.shape[0])
if np.sum(pos==v) == len(v):
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
pos = np.arange(u.shape[0])
if u[pos] + v[u.shape[0] - pos -1]:
return True
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M[:] * v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0450, 2022-04-28 08:06:56, PxP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i=np.arange(len(v))
return v.shape == i.shape and np.sum(v!=i) == 0
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u+v[:,::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0451, 2022-04-28 08:08:01, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i=np.arange(len(v))
return v.shape == i.shape and np.sum(v!=i) == 0
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u+v[:,::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())import numpy as np
def f1(v):
# v: 1-D numpy array
i=np.arange(len(v))
return v.shape == i.shape and np.sum(v!=i) == 0
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u+v
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0452, 2022-04-28 08:08:06, P-P (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i=np.arange(len(v))
return v.shape == i.shape and np.sum(v!=i) == 0
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u+v
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0453, 2022-04-28 08:11:23, PxP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i=np.arange(len(v))
return v.shape == i.shape and np.sum(v!=i) == 0
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u+v[:,::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0454, 2022-04-28 08:11:32, PxP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i=np.arange(len(v))
return v.shape == i.shape and np.sum(v!=i) == 0
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u+v[:,::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0455, 2022-04-28 08:13:17, PxP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i=np.arange(len(v))
return v.shape == i.shape and np.sum(v!=i) == 0
def f2(u, v):
# u and v are 1-D numpy array of equal size
return np.array(u+v[:,::-1]).T
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0456, 2022-04-28 08:14:46, PxP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i=np.arange(len(v))
return v.shape == i.shape and np.sum(v!=i) == 0
def f2(u, v):
# u and v are 1-D numpy array of equal size
x=u+v[:,::-1]
return x.reshape((len(x),1))
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0457, 2022-04-28 08:15:12, PxP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i=np.arange(len(v))
return v.shape == i.shape and np.sum(v!=i) == 0
def f2(u, v):
# u and v are 1-D numpy array of equal size
x=u+v[:,::-1]
return x.reshape((len(x),1))
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0458, 2022-04-28 08:07:30, compilation error (0%)
import numpy as np
def f1(v):
r = np.arange(v.shape[0])
return np.sum(r == v) == v.shape[0]
def f2(u, v):
return u + v[::-1]
def f3(M, v):
return v.dot(M)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0459, 2022-04-28 08:07:54, PPx (67%)
import numpy as np
def f1(v):
r = np.arange(v.shape[0])
return np.sum(r == v) == v.shape[0]
def f2(u, v):
return u + v[::-1]
def f3(M, v):
return v.dot(M)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0460, 2022-04-28 08:10:08, PP- (67%)
import numpy as np
def f1(v):
r = np.arange(v.shape[0])
return np.sum(r == v) == v.shape[0]
def f2(u, v):
return u + v[::-1]
def f3(M, v):
return M.dot(v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0461, 2022-04-28 08:14:26, PPx (67%)
import numpy as np
def f1(v):
r = np.arange(v.shape[0])
return np.sum(r == v) == v.shape[0]
def f2(u, v):
return u + v[::-1]
def f3(M, v):
M = M.reshape((M.shape[0]*M.reshape[1],1))
v = np.arrat([v]).T
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0462, 2022-04-28 08:14:35, PPx (67%)
import numpy as np
def f1(v):
r = np.arange(v.shape[0])
return np.sum(r == v) == v.shape[0]
def f2(u, v):
return u + v[::-1]
def f3(M, v):
M = M.reshape((M.shape[0]*M.reshape[1],1))
v = np.array([v]).T
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0463, 2022-04-28 08:15:19, PPx (67%)
import numpy as np
def f1(v):
r = np.arange(v.shape[0])
return np.sum(r == v) == v.shape[0]
def f2(u, v):
return u + v[::-1]
def f3(M, v):
R = M.reshape((M.shape[0]*M.shape[1],1))
v = np.array([v]).T
return R*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0464, 2022-04-28 08:16:13, PP- (67%)
import numpy as np
def f1(v):
r = np.arange(v.shape[0])
return np.sum(r == v) == v.shape[0]
def f2(u, v):
return u + v[::-1]
def f3(M, v):
R = M.reshape((1,M.shape[0]*M.shape[1]))
v = np.array([v]).T
return R*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0465, 2022-04-28 08:08:14, -xx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(v.shape[0])
return np.sum(a&v) and v.shape[0]
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0466, 2022-04-28 08:10:34, compilation error (0%)
import numpy as np
def f1(v):
a = np.arange(v.shape[0])
return np.sum(a&v) and v.shape[0]
def f2(u, v):
return u + v[::-1]
def f3(M, v):
for k in range(int(input())):
exec(input().strip())
| # 0467, 2022-04-28 08:11:06, -Px (33%)
import numpy as np
def f1(v):
a = np.arange(v.shape[0])
return np.sum(a&v) and v.shape[0]
def f2(u, v):
return u + v[::-1]
def f3(M, v):
pass
for k in range(int(input())):
exec(input().strip())
| # 0468, 2022-04-28 08:14:21, -PP (67%)
import numpy as np
def f1(v) :
a = np.arange(v.shape[0])
return np.sum(a&v) and v.shape[0]
def f2(u, v) :
return u + v[::-1]
def f3(M, v) :
x = v.reshape((1,v.shape[0]))
return M*x
for k in range(int(input())):
exec(input().strip())
| # 0469, 2022-04-28 08:15:22, -PP (67%)
import numpy as np
def f1(v) :
a = np.arange(v.shape[0])
return np.sum(a&v) and v.shape[0]
def f2(u, v) :
return u + v[::-1]
def f3(M, v) :
x = v.reshape((1,v.shape[0]))
return M*x
for k in range(int(input())):
exec(input().strip())
| # 0470, 2022-04-28 08:15:49, xPP (67%)
import numpy as np
def f1(v) :
a = np.arange(v.shape[0])
if v == a : return True
return False
def f2(u, v) :
return u + v[::-1]
def f3(M, v) :
x = v.reshape((1,v.shape[0]))
return M*x
for k in range(int(input())):
exec(input().strip())
| # 0471, 2022-04-28 08:16:17, xPP (67%)
import numpy as np
def f1(v) :
a = np.arange(v.shape[0])
if v == a : return True
return False
def f2(u, v) :
return u + v[::-1]
def f3(M, v) :
x = v.reshape((1,v.shape[0]))
return M*x
for k in range(int(input())):
exec(input().strip())
|
# 0472, 2022-04-28 08:06:19, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(v.shape[0])
if v != pos: return False
else: return True
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0473, 2022-04-28 08:08:31, xPx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(v.shape[0])
if v != pos: return False
else: return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u + v[::-1]
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0474, 2022-04-28 08:11:04, xPx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(v.shape[0])
if v != pos: return False
else: return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.array(M*V)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0475, 2022-04-28 08:12:26, xPP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(v.shape[0])
if v != pos: return False
else: return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.array(v*M)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0476, 2022-04-28 08:14:51, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(v.shape[0])
if v - pos !=: return False
else: return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.array(v*M)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0477, 2022-04-28 08:15:27, xPP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(v.shape[0])
if v - pos != 0: return False
else: return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.array(v*M)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0478, 2022-04-28 08:16:45, xPP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(len(v))
if v - pos != 0: return False
else: return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.array(v*M)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0479, 2022-04-28 08:11:42, --x (0%)
import numpy as np
def f1(v):
check = np.arange(v.shape[0])
if (v != check).sum != 0 :
return False
return True
def f2(u, v):
i = np.arange(u.shape[0])
return np.array([u[i]+v[u.shape[0]-i-1]])
def f3(M, v):
i = np.arange(M.shape[0])
j = np.arange(M.shape[1])
return M[i,j] * v[j]
for k in range(int(input())):
exec(input().strip())
| # 0480, 2022-04-28 08:12:32, -xP (33%)
import numpy as np
def f1(v):
pos = np.arange(v.shape[0])
if np.sum(f1 == pos) != v.shape[0]:
return False
else:
return True
def f2(u,v):
pos1 = np.arange(u.shape[0])
pos2 = np.array([u.shape[0]])-np.arange(v.shape[0])+np.array([1])
return np.array([u[pos1]+v[pos2]])
def f3(M,v):
return np.array(M*v)
for k in range(int(input())):
exec(input().strip())
| # 0481, 2022-04-28 08:13:51, PxP (67%)
import numpy as np
def f1(v):
pos = np.arange(v.shape[0])
if np.sum(v == pos) != v.shape[0]:
return False
else:
return True
def f2(u,v):
pos1 = np.arange(u.shape[0])
pos2 = np.array([u.shape[0]])-np.arange(v.shape[0])+np.array([1])
return np.array([u[pos1]+v[pos2]])
def f3(M,v):
return np.array(M*v)
for k in range(int(input())):
exec(input().strip())
| # 0482, 2022-04-28 08:15:27, compilation error (0%)
import numpy as np
def f1(v):
pos = np.arange(v.shape[0])
if np.sum(v == pos) != v.shape[0]:
return False
else:
return True
def f2(u,v):
pos1 = np.arange(u.shape[0])
pos2 = np.array([u.shape[0]]*V.shape[0])-np.arange(v.shape[0])+np.array([1]v.shape[0])
return np.array([u[pos1]+v[pos2]])
def f3(M,v):
return np.array(M*v)
for k in range(int(input())):
exec(input().strip())
| # 0483, 2022-04-28 08:16:02, compilation error (0%)
import numpy as np
def f1(v):
pos = np.arange(v.shape[0])
if np.sum(v == pos) != v.shape[0]:
return False
else:
return True
def f2(u,v):
pos1 = np.arange(u.shape[0])
pos2 = np.array([u.shape[0]]*v.shape[0])-np.arange(v.shape[0])+np.array([1]v.shape[0])
return np.array([u[pos1]+v[pos2]])
def f3(M,v):
return np.array(M*v)
for k in range(int(input())):
exec(input().strip())
| # 0484, 2022-04-28 08:16:41, PxP (67%)
import numpy as np
def f1(v):
pos = np.arange(v.shape[0])
if np.sum(v == pos) != v.shape[0]:
return False
else:
return True
def f2(u,v):
pos1 = np.arange(u.shape[0])
pos2 = np.array([u.shape[0]]*v.shape[0])-np.arange(v.shape[0])+np.array([1]*v.shape[0])
return np.array([u[pos1]+v[pos2]])
def f3(M,v):
return np.array(M*v)
for k in range(int(input())):
exec(input().strip())
| # 0485, 2022-04-28 08:17:12, PxP (67%)
import numpy as np
def f1(v):
pos = np.arange(v.shape[0])
if np.sum(v == pos) != v.shape[0]:
return False
else:
return True
def f2(u,v):
pos1 = np.arange(u.shape[0])
pos2 = np.array([u.shape[0]]*v.shape[0])-np.arange(v.shape[0])+np.array([1]*v.shape[0])
return np.array([u[pos1]+v[pos2]])
def f3(M,v):
return np.array(M*v)
for k in range(int(input())):
exec(input().strip())
|
# 0486, 2022-04-28 08:09:34, -Px (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
#for i in range(v.shape[0]):
return np.sum(np.arange(v.shape[0]) == v) == 0
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.dot(v, M)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0487, 2022-04-28 08:10:03, -Px (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return np.sum(np.arange(v.shape[0]) == v) == 0
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.dot(v, M)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0488, 2022-04-28 08:11:42, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return np.sum(np.arange(v.shape[0]) == v) == v.shape[0]
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.dot(v, M)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0489, 2022-04-28 08:14:16, PP- (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return np.sum(np.arange(v.shape[0]) == v) == v.shape[0]
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.dot(M, v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0490, 2022-04-28 08:16:32, PP- (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return np.sum(np.arange(v.shape[0]) == v) == v.shape[0]
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.sum(M*v, axis=1)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0491, 2022-04-28 08:16:52, PP- (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return np.sum(np.arange(v.shape[0]) == v) == v.shape[0]
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.sum(M*v, axis=0)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0492, 2022-04-28 08:17:06, PP- (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return np.sum(np.arange(v.shape[0]) == v) == v.shape[0]
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.dot(M,v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0493, 2022-04-28 08:05:08, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i=v.shape[0]
if v[i] != i: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0494, 2022-04-28 08:08:15, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i=v.shape[0]
if v[i] != i: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0495, 2022-04-28 08:11:55, xPP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
t = np.arange(len(v.shape[0]))
if np.min(t == v) == 0:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return np.array(u+v[::-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.array(M*v)
# ----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0496, 2022-04-28 08:12:07, xPP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
t = np.arange(len(v.shape[0]))
if np.min(t == v) == 0:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return np.array(u+v[::-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.array(M*v)
# ----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0497, 2022-04-28 08:14:17, xPP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
t = np.arange(len(v.shape[0]))
return np.min(t == v)
def f2(u, v):
# u and v are 1-D numpy array of equal size
return np.array(u+v[::-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.array(M*v)
# ----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0498, 2022-04-28 08:15:11, xPP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
t = np.arange(len(v.shape[1]))
return np.min(t == v)
def f2(u, v):
# u and v are 1-D numpy array of equal size
return np.array(u+v[::-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.array(M*v)
# ----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0499, 2022-04-28 08:15:54, xPP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
t = np.arange(len(v.shape[0]))
return np.min(t == v)
def f2(u, v):
# u and v are 1-D numpy array of equal size
return np.array(u+v[::-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.array(M*v)
# ----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0500, 2022-04-28 08:08:48, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(0,v.shape[0])
a = v==pos
if np.sum(a) == 0:
return False
else:
return True
| # 0501, 2022-04-28 08:09:13, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(0,v.shape[0])
a = v==pos
if np.sum(a) == 0:
return True
else:
return False
| # 0502, 2022-04-28 08:09:57, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(0,v.shape[0])
a = v==pos
if np.sum(a) == 0:
return False
else:
return True
| # 0503, 2022-04-28 08:10:35, -xx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(0,v.shape[0])
a = v==pos
if np.sum(a) == 0:
return False
else:
return True
for k in range(int(input())):
exec(input().strip())
| # 0504, 2022-04-28 08:12:22, -xx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(0,v.shape[0])
a = v==pos
if np.sum(a) == 0:
return True
else:
return False
for k in range(int(input())):
exec(input().strip())
| # 0505, 2022-04-28 08:13:30, -xP (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(0,v.shape[0])
a = v==pos
if np.sum(a) == 0:
return True
else:
return False
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
for k in range(int(input())):
exec(input().strip())
| # 0506, 2022-04-28 08:14:55, -PP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(0,v.shape[0])
a = v==pos
if np.sum(a) == 0:
return True
else:
return False
def f2(u, v):
return u+v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
for k in range(int(input())):
exec(input().strip())
|
# 0507, 2022-04-28 08:08:00, xx- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
#for i in range(v.shape[0]):
#if v[i] != i: return False
return v[0] == 0 and v[1] == 1 and v[2] == 2 and v[3] == 3
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.dot(M, v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0508, 2022-04-28 08:13:14, x-x (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
#for i in range(v.shape[0]):
#if v[i] != i: return False
return v[0] == 0 and v[1] == 1 and v[2] == 2 and v[3] == 3
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
#return np.array([u[i]+v[n-i-1] for i in range(n)])
return (u[0] + v[n-1]) + (u[1] + v[n-2]) + (u[2] + v[n-3])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.dot(M[:,1], v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0509, 2022-04-28 08:14:04, x-x (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
#for i in range(v.shape[0]):
#if v[i] != i: return False
return v[0] == 0 and v[1] == 1 and v[2] == 2 and v[3] == 3
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
#return np.array([u[i]+v[n-i-1] for i in range(n)])
return (u[0] + v[n-1]) + (u[1] + v[n-2]) + (u[2] + v[n-3])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.dot(M[:,0], v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0510, 2022-04-28 08:16:11, xPx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
#for i in range(v.shape[0]):
#if v[i] != i: return False
return v[0] == 0 and v[1] == 1 and v[2] == 2 and v[3] == 3
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
#return np.array([u[i]+v[n-i-1] for i in range(n)])
return v[::-1]+u
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.dot(M[:,0], v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0511, 2022-04-28 08:16:20, xPx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
#for i in range(v.shape[0]):
#if v[i] != i: return False
return v[0] == 0 and v[1] == 1 and v[2] == 2 and v[3] == 3
def f2(u, v):
# u and v are 1-D numpy array of equal size
#return np.array([u[i]+v[n-i-1] for i in range(n)])
return v[::-1]+u
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.dot(M[:,0], v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0512, 2022-04-28 08:16:36, xPP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
#for i in range(v.shape[0]):
#if v[i] != i: return False
return v[0] == 0 and v[1] == 1 and v[2] == 2 and v[3] == 3
def f2(u, v):
# u and v are 1-D numpy array of equal size
#return np.array([u[i]+v[n-i-1] for i in range(n)])
return v[::-1]+u
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M * v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0513, 2022-04-28 08:17:04, -PP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
#for i in range(v.shape[0]):
#if v[i] != i: return False
return np.all(v != np.arange(v.shape[0]))
def f2(u, v):
# u and v are 1-D numpy array of equal size
#return np.array([u[i]+v[n-i-1] for i in range(n)])
return v[::-1]+u
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M * v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0514, 2022-04-28 08:11:19, --- (0%) import numpy as np def f1(v): # v: 1-D numpy array a=np.arange(v.shape[0]) if a[:,:]==v[:,:]:return True else: return False def f2(u, v): # u and v are 1-D numpy array of equal size n = u.shape[0] return np.array([u[i]+v[n-i-1] for i in range(n)]) def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] return | # 0515, 2022-04-28 08:12:53, --- (0%) import numpy as np def f1(v): # v: 1-D numpy array a=np.arange(v.shape[0]) if a[:,:]==v[:,:]: return True else: return False def f2(u, v): # u and v are 1-D numpy array of equal size s=v[::-1] return u+v def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] return | # 0516, 2022-04-28 08:13:13, --- (0%) import numpy as np def f1(v): # v: 1-D numpy array a=np.arange(v.shape[0]) if a[:,:]==v[:,:]: return True else: return False def f2(u, v): # u and v are 1-D numpy array of equal size s=v[::-1] return u+v def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] return M*v | # 0517, 2022-04-28 08:13:27, --- (0%) import numpy as np def f1(v): # v: 1-D numpy array a=np.arange(v.shape[0]) if a[:,:]==v[:,:]: return True else: return False def f2(u, v): # u and v are 1-D numpy array of equal size s=v[::-1] return u+v def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] return M*v | # 0518, 2022-04-28 08:14:37, --- (0%) import numpy as np def f1(v): # v: 1-D numpy array a=np.arange(v.shape[0]) if a[:,:]==v[:,:]: return True else: return False def f2(u, v): # u and v are 1-D numpy array of equal size s=v[::-1] return u+s def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] return M*v | # 0519, 2022-04-28 08:15:30, xPP (67%) import numpy as np def f1(v): # v: 1-D numpy array a=np.arange(v.shape[0]) if a[:,:]==v[:,:]: return True else: return False def f2(u, v): # u and v are 1-D numpy array of equal size s=v[::-1] return u+s def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] return M*v for k in range(int(input())): exec(input().strip()) |
# 0520, 2022-04-28 08:01:18, xxx (0%) u | # 0521, 2022-04-28 08:04:49, compilation error (0%)
import numpy as np
def f1(v):
a=np.arange(v.shape[0])
if v==a:
return True
else return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0522, 2022-04-28 08:12:49, xPP (67%)
import numpy as np
def f1(v):
a=np.arange(v.shape[0])
if v==a:
return True
else:
return False
def f2(u, v):
n = u.shape[0]
u2=np.array(u)
v2=np.array(v)
v3=v2[::-1]
return u2+v3
def f3(M, v):
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0523, 2022-04-28 08:13:53, xPP (67%)
import numpy as np
def f1(v):
return x
def f2(u, v):
n = u.shape[0]
u2=np.array(u)
v2=np.array(v)
v3=v2[::-1]
return u2+v3
def f3(M, v):
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0524, 2022-04-28 08:14:20, xPP (67%)
import numpy as np
def f1(v):
a=np.arange(v.shape[0])
if v==a:
return True
else:
return False
def f2(u, v):
n = u.shape[0]
u2=np.array(u)
v2=np.array(v)
v3=v2[::-1]
return u2+v3
def f3(M, v):
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0525, 2022-04-28 08:15:32, xPP (67%)
import numpy as np
def f1(v):
a=np.arange(int(len(v)))
if v==a:
return True
else:
return False
def f2(u, v):
n = u.shape[0]
u2=np.array(u)
v2=np.array(v)
v3=v2[::-1]
return u2+v3
def f3(M, v):
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0526, 2022-04-28 08:13:22, -Px (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
vv = np.arange(len(v))
compare_result = v == vv
return compare_result
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
x = u+v[n-1::-1]
return x
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0527, 2022-04-28 08:13:58, -PP (67%) import numpy as np def f1(v): # v: 1-D numpy array vv = np.arange(len(v)) compare_result = v == vv return compare_result def f2(u, v): # u and v are 1-D numpy array of equal size n = u.shape[0] x = u+v[n-1::-1] return x def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] return np.array(M*v) #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0528, 2022-04-28 08:15:21, -PP (67%) import numpy as np def f1(v): # v: 1-D numpy array vv = np.arange(len(v)) return v ==vv def f2(u, v): # u and v are 1-D numpy array of equal size n = u.shape[0] x = u+v[n-1::-1] return x def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] return np.array(M*v) #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0529, 2022-04-28 08:16:09, -PP (67%) import numpy as np def f1(v): # v: 1-D numpy array vv = np.arange(len(v)) return v == vv def f2(u, v): # u and v are 1-D numpy array of equal size n = u.shape[0] x = u+v[n-1::-1] return x def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] return np.array(M*v) #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0530, 2022-04-28 08:16:42, xPP (67%) import numpy as np def f1(v): # v: 1-D numpy array vv = np.arange(v.ahape[0]) return v == vv def f2(u, v): # u and v are 1-D numpy array of equal size n = u.shape[0] x = u+v[n-1::-1] return x def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] return np.array(M*v) #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0531, 2022-04-28 08:16:48, -PP (67%) import numpy as np def f1(v): # v: 1-D numpy array vv = np.arange(v.shape[0]) return v == vv def f2(u, v): # u and v are 1-D numpy array of equal size n = u.shape[0] x = u+v[n-1::-1] return x def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] return np.array(M*v) #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) |
# 0532, 2022-04-28 08:04:34, compilation error (0%) import numpy as np def f1(v): # v: 1-D numpy array for i in range(v.shape[0]): if v[i] != i: return False return True download code นี def f2(u, v): # u and v are 1-D numpy array of equal size n = u.shape[0] return np.array([u[i]+v[n-i-1] for i in range(n)]) def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] A = [] for i in range(M.shape[0]): a = [] for j in range(M.shape[1]): a.append(M[i,j] * v[j]) A.append(a) return np.array(A) #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0533, 2022-04-28 08:04:49, compilation error (0%) import numpy as np def f1(v): # v: 1-D numpy array # for i in range(v.shape[0]): # if v[i] != i: return False # return True a = v != np.arange(v.shape[0]) if np.sum(a) == 0: return True else: return False def f2(u, v): # u and v are 1-D numpy array of equal size n = u.shape[0] return np.array([u[i]+v[n-i-1] for i in range(n)]) def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] A = [] for i in range(M.shape[0]): a = [] for j in range(M.shape[1]): a.append(M[i,j] * v[j]) A.append(a) return np.array(A) #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0534, 2022-04-28 08:09:32, PPx (67%) import numpy as np def f1(v): # v: 1-D numpy array # for i in range(v.shape[0]): # if v[i] != i: return False # return True a = v != np.arange(v.shape[0]) if np.sum(a) == 0: return True else: return False def f2(u, v): # u and v are 1-D numpy array of equal size n = u.shape[0] a = u + v[::-1] return a def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] A = [] for i in range(M.shape[0]): a = [] for j in range(M.shape[1]): a.append(M[i,j] * v[j]) A.append(a) return np.array(A) a = v*M.reshape(1, -1) return a #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0535, 2022-04-28 08:09:59, PPx (67%) import numpy as np def f1(v): # v: 1-D numpy array # for i in range(v.shape[0]): # if v[i] != i: return False # return True a = v != np.arange(v.shape[0]) if np.sum(a) == 0: return True else: return False def f2(u, v): # u and v are 1-D numpy array of equal size n = u.shape[0] a = u + v[::-1] return a def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] a = v*M.reshape(1, -1) return a #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0536, 2022-04-28 08:13:36, PP- (67%) import numpy as np def f1(v): # v: 1-D numpy array # for i in range(v.shape[0]): # if v[i] != i: return False # return True a = v != np.arange(v.shape[0]) if np.sum(a) == 0: return True else: return False def f2(u, v): # u and v are 1-D numpy array of equal size n = u.shape[0] a = u + v[::-1] return a def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] a = v*M return a.reshape(1, -1) #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0537, 2022-04-28 08:15:12, PP- (67%) import numpy as np def f1(v): # v: 1-D numpy array # for i in range(v.shape[0]): # if v[i] != i: return False # return True a = v != np.arange(v.shape[0]) if np.sum(a) == 0: return True else: return False def f2(u, v): # u and v are 1-D numpy array of equal size n = u.shape[0] a = u + v[::-1] return a def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] a = v*M return a.ravel() #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) |
# 0538, 2022-04-28 08:11:20, -P- (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if np.sum(v[:]!=np.arange(v.shape[0])) != v.shape[0]:
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return np.array(u[:]+v[u.shape[0]-1::-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.dot(M,v.T)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0539, 2022-04-28 08:12:16, PP- (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if np.sum(v[:]!=np.arange(v.shape[0])) > 0:
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return np.array(u[:]+v[u.shape[0]-1::-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.dot(M,v.T)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0540, 2022-04-28 08:12:37, PP- (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if np.sum(v[:]!=np.arange(v.shape[0])) > 0:
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return np.array(u[:]+v[u.shape[0]-1::-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.dot(M,v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0541, 2022-04-28 08:14:15, PP- (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if np.sum(v[:]!=np.arange(v.shape[0])) > 0:
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return np.array(u[:]+v[u.shape[0]-1::-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M.dot(v.T)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0542, 2022-04-28 08:14:49, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if np.sum(v[:]!=np.arange(v.shape[0])) > 0:
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return np.array(u[:]+v[u.shape[0]-1::-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return v.T.dot(M)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0543, 2022-04-28 08:11:09, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return v == np.arange(v.shape[0])
| # 0544, 2022-04-28 08:12:09, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if v == np.arange(v.shape[0]):
return True
return False
| # 0545, 2022-04-28 08:13:40, xPP (67%)
import numpy as np
def f1(v):
if v == np.arange(v.shape[0]):
return True
return False
def f2(u, v):
a = u + v[::-1]
return a
def f3(M, v):
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0546, 2022-04-28 08:14:47, xPP (67%)
import numpy as np
def f1(v):
if v == np.arange(v.shape[0]):
return False
return True
def f2(u, v):
a = u + v[::-1]
return a
def f3(M, v):
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0547, 2022-04-28 08:16:00, xPP (67%)
import numpy as np
def f1(v):
if v == np.arange(v.shape[0]):
return True
return False
def f2(u, v):
a = u + v[::-1]
return a
def f3(M, v):
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0548, 2022-04-28 08:10:50, -xx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
posv = np.arange(0,np.shape(v)[0])
out = posv == v
if np.sum(out) == np.shape(v)[0]:
return True
return False
print(f1(np.array([1,1,2,3])))
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0549, 2022-04-28 08:11:49, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
posv = np.arange(0,np.shape(v)[0])
out = posv == v
if np.sum(out) == np.shape(v)[0]:
return True
return False
print(f1(np.array([1,1,2,3])))
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u[:] + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
| # 0550, 2022-04-28 08:12:29, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
posv = np.arange(0,np.shape(v)[0])
out = posv == v
if np.sum(out) == np.shape(v)[0]:
return True
return False
def f2(u,v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u[:] + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0551, 2022-04-28 08:14:33, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
posv = np.arange(0,np.shape(v)[0])
ans = posv == v
if np.sum(ans) == np.shape(v)[0]:
return True
return False
def f2(u,v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u[:] + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0552, 2022-04-28 08:15:08, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(0,np.shape(v)[0])
ans = pos == v
if np.sum(ans) == np.shape(v)[0]:
return True
return False
def f2(u,v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u[:] + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0553, 2022-04-28 08:09:46, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i = np.arange(0,len(v))
if np.sum(v == i) == len(v):
return True
else:
return False
| # 0554, 2022-04-28 08:11:35, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i = np.arange(0,len(v))
if np.sum(v == i) == len(v):
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
v_new = v[,::-1]
last = u + v
return np.array(last)
| # 0555, 2022-04-28 08:13:00, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i = np.arange(0,len(v))
if np.sum(v == i) == len(v):
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
v_new = v[,::-1]
last = u + v
return np.array(last)
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = M*v
return np.array(A)
| # 0556, 2022-04-28 08:13:26, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i = np.arange(0,len(v))
if np.sum(v == i) == len(v):
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
v_new = v[,::-1]
last = u + v
return np.array(last)
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = M*v
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0557, 2022-04-28 08:14:10, P-P (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i = np.arange(0,len(v))
if np.sum(v == i) == len(v):
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
v_new = v[::-1]
last = u + v
return np.array(last)
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = M*v
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0558, 2022-04-28 08:11:56, compilation error (0%)
import numpy as np
def f1(v):
a = np.arange(v.shape[0]):
c = v[a] != a:
if np.sum(c) != 0:
return False
return True
def f2(u, v):
n = u.shape[0]
a = np.arange(n)
ain = a[::-1]
return u[a]+v[ain]
def f3(M, v):
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0559, 2022-04-28 08:12:21, PPx (67%)
import numpy as np
def f1(v):
a = np.arange(v.shape[0])
c = v[a] != a
if np.sum(c) != 0:
return False
return True
def f2(u, v):
n = u.shape[0]
a = np.arange(n)
ain = a[::-1]
return u[a]+v[ain]
def f3(M, v):
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0560, 2022-04-28 08:14:10, PP- (67%)
import numpy as np
def f1(v):
a = np.arange(v.shape[0])
c = v[a] != a
if np.sum(c) != 0:
return False
return True
def f2(u, v):
n = u.shape[0]
a = np.arange(n)
ain = a[::-1]
return u[a]+v[ain]
def f3(M, v):
return np.dot(M,v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0561, 2022-04-28 08:16:34, PPx (67%)
import numpy as np
def f1(v):
a = np.arange(v.shape[0])
c = v[a] != a
if np.sum(c) != 0:
return False
return True
def f2(u, v):
n = u.shape[0]
a = np.arange(n)
ain = a[::-1]
return u[a]+v[ain]
def f3(M, v):
return np.dot(v,M)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0562, 2022-04-28 08:17:00, PP- (67%)
import numpy as np
def f1(v):
a = np.arange(v.shape[0])
c = v[a] != a
if np.sum(c) != 0:
return False
return True
def f2(u, v):
n = u.shape[0]
a = np.arange(n)
ain = a[::-1]
return u[a]+v[ain]
def f3(M, v):
return np.dot(M,v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0563, 2022-04-28 08:13:02, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
for i in range(v.shape[0]):
if v[i] != i: return False
i = np.arange(v.shape[0])
if v[:i] != i:
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
# print(u)
# print(v[::-1])
return np.array(u+v[::-1])
# u = np.array([1,2,3])
# v = np.array([4,5,6])
# print(f2(u, v))
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.array(M*v)
| # 0564, 2022-04-28 08:13:23, xPP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
for i in range(v.shape[0]):
if v[i] != i: return False
i = np.arange(v.shape[0])
if v[:i] != i:
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
# print(u)
# print(v[::-1])
return np.array(u+v[::-1])
# u = np.array([1,2,3])
# v = np.array([4,5,6])
# print(f2(u, v))
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.array(M*v)
for k in range(int(input())):
exec(input().strip())
| # 0565, 2022-04-28 08:13:45, xPP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i = np.arange(v.shape[0])
if v[:i] != i:
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
# print(u)
# print(v[::-1])
return np.array(u+v[::-1])
# u = np.array([1,2,3])
# v = np.array([4,5,6])
# print(f2(u, v))
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.array(M*v)
for k in range(int(input())):
exec(input().strip())
| # 0566, 2022-04-28 08:14:00, xPP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i = np.arange(v.shape[0])
if v[i] != i:
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
# print(u)
# print(v[::-1])
return np.array(u+v[::-1])
# u = np.array([1,2,3])
# v = np.array([4,5,6])
# print(f2(u, v))
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.array(M*v)
for k in range(int(input())):
exec(input().strip())
| # 0567, 2022-04-28 08:16:05, xPP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i = np.arange(v.shape[0])
if v[v != i] :
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
# print(u)
# print(v[::-1])
return np.array(u+v[::-1])
# u = np.array([1,2,3])
# v = np.array([4,5,6])
# print(f2(u, v))
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.array(M*v)
for k in range(int(input())):
exec(input().strip())
|
# 0568, 2022-04-28 08:06:21, -xx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x = np.arange(v.shape[0])
z = np.sum(v-x==0)
if z>0:
return False
else:
return True
for k in range(int(input())):
exec(input().strip())
| # 0569, 2022-04-28 08:07:07, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x = np.arange(v.shape[0])
z = np.sum(v-x!=0)
if z>0:
return False
else:
return True
for k in range(int(input())):
exec(input().strip())
| # 0570, 2022-04-28 08:11:04, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x = np.arange(v.shape[0])
z = np.sum(v-x!=0)
if z>0:
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
#return np.array([u[i]+v[n-i-1] for i in range(n)])
v2 = v[n-1:-2]
return u+v2
for k in range(int(input())):
exec(input().strip())
| # 0571, 2022-04-28 08:12:40, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x = np.arange(v.shape[0])
z = np.sum(v-x!=0)
if z>0:
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
#return np.array([u[i]+v[n-i-1] for i in range(n)])
v2 = v[n-1:-2]+v[:-2]
return u+v2
for k in range(int(input())):
exec(input().strip())
| # 0572, 2022-04-28 08:13:44, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x = np.arange(v.shape[0])
z = np.sum(v-x!=0)
if z>0:
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
#return np.array([u[i]+v[n-i-1] for i in range(n)])
return np.array(u[:]+v[n-1::-1])
for k in range(int(input())):
exec(input().strip())
|
# 0573, 2022-04-28 08:04:53, xxx (0%)
def f1(v):
# v: 1-D numpy array
return v == a.range(v.shape[0])
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0574, 2022-04-28 08:05:29, xxx (0%)
def f1(v):
# v: 1-D numpy array
return v == np.arange(v.shape[0])
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0575, 2022-04-28 08:12:15, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if np.sum(v == np.arange(v.shape[0]))==v.shape[0]:
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
pass
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
pass
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0576, 2022-04-28 08:16:23, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if np.sum(v == np.arange(v.shape[0]))==v.shape[0]:
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u+v[-1::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
pass
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0577, 2022-04-28 08:05:13, xxx (0%) import numpy as np def f1(v): # v: 1-D numpy array a = v.shape[0] if v != np.arange(a): return False return True #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0578, 2022-04-28 08:11:35, xPx (33%) import numpy as np def f1(v): # v: 1-D numpy array a = v.shape[0] if v != np.arange(a): return False return True def f2(u, v): # u and v are 1-D numpy array of equal size n = u.shape[0] x = v[::-1] ans = u+x return(ans) #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0579, 2022-04-28 08:13:56, xP- (33%) import numpy as np def f1(v): # v: 1-D numpy array a = v.shape[0] if v != np.arange(a): return False return True def f2(u, v): # u and v are 1-D numpy array of equal size n = u.shape[0] x = v[::-1] ans = u+x return(ans) def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] x = M.dot(v) return(x) #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0580, 2022-04-28 08:15:24, PP- (67%) import numpy as np def f1(v): # v: 1-D numpy array a = v.shape[0] if np.sum(v != np.arange(a)) != 0: return False return True def f2(u, v): # u and v are 1-D numpy array of equal size n = u.shape[0] x = v[::-1] ans = u+x return(ans) def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] x = M.dot(v) return(x) #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) |
# 0581, 2022-04-28 08:08:00, xxP (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
for i in range(v.shape[0]):
if v[i] != i: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u[::1]-n[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0582, 2022-04-28 08:11:16, xxP (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
n = len(v)
j = v != np.arange(v)
if j.sum() != 0 :return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u[::1]-n[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0583, 2022-04-28 08:14:47, xPP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
n = len(v)
j = v != np.arange(v)
if j.sum() != 0 :return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u + v[-1::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0584, 2022-04-28 08:16:52, xPP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
n = len(v)
j = v != v[np.arange(v)]
if j.sum() != 0 :return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u + v[-1::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0585, 2022-04-28 08:14:31, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
c = np.arange(0,v.shape[0])
k = sum(v != c)
if k == 0:
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
c = u[:] + v[::-1]
return c
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0586, 2022-04-28 08:15:19, -PP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
c = np.arange(0,v.shape[0])
k = sum(v != c)
if k == 0:
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
c = u[:] + v[::-1]
return c
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
z = M * v
return z
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0587, 2022-04-28 08:16:24, -PP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
c = np.arange(0,v.shape[0])
k = sum(v != c)
return k
def f2(u, v):
# u and v are 1-D numpy array of equal size
c = u[:] + v[::-1]
return c
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
z = M * v
return z
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0588, 2022-04-28 08:16:41, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
c = np.arange(0,v.shape[0])
k = sum(v != c)
if k == 0:
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
c = u[:] + v[::-1]
return c
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0589, 2022-04-28 08:04:03, xxx (0%) a | # 0590, 2022-04-28 08:14:32, -PP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a=np.arange(v.shape[0])
if np.sum(v!=a)!=v.shape[0]:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u+v[-1::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0591, 2022-04-28 08:15:08, -PP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u+v[-1::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0592, 2022-04-28 08:15:26, -PP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u+v[-1::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0593, 2022-04-28 08:09:00, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i = np.arange(v.shape[0])
return v[v == i ]
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
i = np.arange(n)
return np.array(u[i]+v[n-i-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = [] ; a = []
a.append(M[:,:] * v[:])
A.append(a)
return np.array(A)
| # 0594, 2022-04-28 08:10:26, -P- (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i = np.arange(v.shape[0])
return v[v == i ]
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
i = np.arange(n)
return np.array(u[i]+v[n-i-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = [] ; a = []
a.append(M[:,:] * v[:])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0595, 2022-04-28 08:15:52, -P- (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i = np.arange(v.shape[0])
v = v[v == i]
return v[v == True]
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
i = np.arange(n)
return np.array(u[i]+v[n-i-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = [] ; a = []
a.append(M[:,:] * v[:])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0596, 2022-04-28 08:16:42, -PP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i = np.arange(v.shape[0])
v = v[v == i]
return v[v == True]
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
i = np.arange(n)
return np.array(u[i]+v[n-i-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0597, 2022-04-28 08:08:13, xP- (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
recheck=np.arange(v.shape[0]+1,dtype='int')
bool_= v==recheck
if False in bool_:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
sum_=u+v[::-1]
return sum_
#return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A=list()
v=v.T
out=np.dot(M,v)
return out
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0598, 2022-04-28 08:15:11, xP- (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
recheck=np.arange(v.shape[0]+1,dtype='int')
bool_= v==recheck
if bool_:
return True
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
sum_=u+v[::-1]
return sum_
#return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A=list()
v=v.T
out=np.dot(M,v)
return out
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0599, 2022-04-28 08:16:07, xP- (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
recheck=np.arange(v.shape[0],dtype='int')
bool_= v==recheck
if bool_:
return True
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
sum_=u+v[::-1]
return sum_
#return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A=list()
v=v.T
out=np.dot(M,v)
return out
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0600, 2022-04-28 08:16:53, PP- (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
recheck=np.arange(v.shape[0],dtype='int')
bool_= v==recheck
if False in bool_:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
sum_=u+v[::-1]
return sum_
#return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A=list()
v=v.T
out=np.dot(M,v)
return out
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0601, 2022-04-28 08:08:24, xP- (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if v == np.arange(v.shape[0]):
return True
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
v_new = v[::-1]
return (u+v_new)
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.dot(M,v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0602, 2022-04-28 08:13:05, PP- (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
k = np.arange(v.shape[0])
con = (v==k)
if con.sum()==v.shape[0]:
return True
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
v_new = v[::-1]
return (u+v_new)
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.dot(M,v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0603, 2022-04-28 08:14:35, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
k = np.arange(v.shape[0])
con = (v==k)
if con.sum()==v.shape[0]:
return True
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
v_new = v[::-1]
return (u+v_new)
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.dot(M.T,v.T)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0604, 2022-04-28 08:16:24, PP- (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
k = np.arange(v.shape[0])
con = (v==k)
if con.sum()==v.shape[0]:
return True
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
v_new = v[::-1]
return (u+v_new)
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.dot(v,M.T)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0605, 2022-04-28 08:14:38, --- (0%)
import numpy as np
def f1(v):
a=np.arange(v.shape[0])
return v==a
# v: 1-D numpy array
def f2(u, v):
return u+v[::-1]
def f3(M, v):
return M*v
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
#----- DON'T modify any of the following lines -----
#for k in range(int(input())):
#exec(input().strip())
| # 0606, 2022-04-28 08:15:15, -PP (67%)
import numpy as np
def f1(v):
a=np.arange(v.shape[0])
return v==a
# v: 1-D numpy array
def f2(u, v):
return u+v[::-1]
def f3(M, v):
return M*v
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0607, 2022-04-28 08:17:14, -PP (67%)
import numpy as np
def f1(v):
a=np.arange(v.shape[0])
return np.min(a==v)==0
# v: 1-D numpy array
def f2(u, v):
return u+v[::-1]
def f3(M, v):
return M*v
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0608, 2022-04-28 08:07:35, Pxx (33%)
import numpy as np
def f1(v: np.ndarray):
# v: 1-D numpy array
return np.array_equal(np.arange(v.shape[0]), v)
def f2(u, v):
# u and v are 1-D numpy array of equal size
index = np.arange(u.shape[0])
return np.sum(u[index] + v[u.shape[0] - index - 1], axis=1)
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M * v.reshape(M.shape[0], 1)
# ----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0609, 2022-04-28 08:09:19, Pxx (33%)
import numpy as np
def f1(v: np.ndarray):
# v: 1-D numpy array
return np.array_equal(np.arange(v.shape[0]), v)
def f2(u, v):
# u and v are 1-D numpy array of equal size
index = np.arange(u.shape[0])
return np.sum(u[index] + v[u.shape[0] - index - 1], axis=1)
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M * v.reshape(1, M.shape[0])
# ----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0610, 2022-04-28 08:14:03, PxP (67%)
import numpy as np
def f1(v: np.ndarray):
# v: 1-D numpy array
return np.array_equal(np.arange(v.shape[0]), v)
def f2(u, v):
# u and v are 1-D numpy array of equal size
index = np.arange(u.shape[0])
u[index] + v[u.shape[0] - index - 1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M * v.reshape(1, M.shape[1])
# ----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0611, 2022-04-28 08:08:53, -P- (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a=np.arange(v.shape[0])
b= v!=a
if False in b:
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return np.array(u+v[::-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A=list(np.dot(M,v))
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0612, 2022-04-28 08:13:36, PP- (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a=np.arange(v.shape[0])
b= v==a
if False in b:
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return np.array(u+v[::-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A=list(np.dot(M,v))
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0613, 2022-04-28 08:14:56, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a=np.arange(v.shape[0])
b= v==a
if False in b:
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return np.array(u+v[::-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A=list(np.dot(v,M))
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0614, 2022-04-28 08:09:54, -xx (0%)
import numpy as np
def f1(v):
return v[0]==v.shape[0]
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0615, 2022-04-28 08:14:36, xPx (33%)
import numpy as np
def f1(v):
s = np.arange(0,len(v))
if np.sum(s==x)==len(v):
return True
else:
return False
def f2(u, v):
a = u[::]
b = v[len(v)::-1]
m = a+b
return np.array(m)
#def f3(M,v):
#return
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0616, 2022-04-28 08:16:56, PPx (67%)
import numpy as np
def f1(v):
s = np.arange(0,len(v))
if np.sum(s==v)==len(v):
return True
else:
return False
def f2(u, v):
a = u[::]
b = v[len(v)::-1]
m = a+b
return np.array(m)
#def f3(M,v):
#return
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0617, 2022-04-28 08:12:26, compilation error (0%)
import numpy as np
def f1(v):
v = np.array([1,2,3])
n = np.arange(v.shape[0])
x = v==
return x
def f2(u, v):
a = np.arange(v.shape[0])
return u[a]+v[a[::-1]]
for k in range(int(input())):
exec(input().strip())
| # 0618, 2022-04-28 08:14:00, compilation error (0%)
import numpy as np
def f1(v):
v = np.array([1,2,3])
n = np.arange(v.shape[0])
x = v==
return x
def f2(u, v):
a = np.arange(v.shape[0])
return u[a]+v[a[::-1]]
def f3(M, v):
return M*v
for k in range(int(input())):
exec(input().strip())
| # 0619, 2022-04-28 08:14:43, -PP (67%)
import numpy as np
def f1(v):
v = np.array([1,2,3])
n = np.arange(v.shape[0])
x = v==n
return x
def f2(u, v):
a = np.arange(v.shape[0])
return u[a]+v[a[::-1]]
def f3(M, v):
return M*v
for k in range(int(input())):
exec(input().strip())
|
# 0620, 2022-04-28 08:12:57, -xP (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if np.sum(v != np.arange(1,len(v))) : return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u+v[u.shape[0]-1][::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0621, 2022-04-28 08:15:01, -PP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if np.sum(v != np.arange(1,len(v))) : return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u+v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0622, 2022-04-28 08:16:50, -PP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if np.sum(v == np.arange(1,len(v))) != 0 : return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u+v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0623, 2022-04-28 08:14:56, xPP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
row,col = v.shape
n = np.arange(row)
test1 = v[:] != n
if False in test1:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return np.array(u[0:] + v[v.shape[0]::-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
x = M.shape[0]
y =M.shape[1]
return M[:x,:y] * v[:y]
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0624, 2022-04-28 08:15:03, xPP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
row,col = v.shape
n = np.arange(row)
test1 = v[:] != n
if False in test1:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return np.array(u[0:] + v[v.shape[0]::-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
x = M.shape[0]
y =M.shape[1]
return M[:x,:y] * v[:y]
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0625, 2022-04-28 08:15:06, xPP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
row,col = v.shape
n = np.arange(row)
test1 = v[:] != n
if False in test1:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return np.array(u[0:] + v[v.shape[0]::-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
x = M.shape[0]
y =M.shape[1]
return M[:x,:y] * v[:y]
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0626, 2022-04-28 08:10:26, -Px (33%)
import numpy as np
def f1(v):
i = np.arange(v.shape[0])
if np.sum(v != 0) != 0: return False
else: return True
def f2(u, v):
return u + v[::-1]
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0627, 2022-04-28 08:12:17, -PP (67%)
import numpy as np
def f1(v):
i = np.arange(v.shape[0])
if np.sum(v != 0) != 0: return False
else: return True
def f2(u, v):
return u + v[::-1]
def f3(M, v):
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0628, 2022-04-28 08:12:51, -PP (67%)
import numpy as np
def f1(v):
i = np.arange(v.shape[0])
if np.sum(v != 0) != 0: return False
return True
def f2(u, v):
return u + v[::-1]
def f3(M, v):
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0629, 2022-04-28 08:13:24, --P (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
check = np.arange(1,v.shape[0]+1)
if np.sum(v==check)==v.shape[0]:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return np.array([u+v[::-1]])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0630, 2022-04-28 08:15:28, -PP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
check = np.arange(1,v.shape[0]+1)
if np.sum(v==check)==v.shape[0]:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u+v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0631, 2022-04-28 08:16:51, -PP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
check = np.arange(1,v.shape[0]+1)
if np.sum(v==check)==v.shape[0]:
return True
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u+v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0632, 2022-04-28 08:12:03, P-x (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(len(v))
check = np.sum(pos != v)
if check != 0:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
a = v[::-1]
return np.array(u+v)
def f3(M, v):
pass
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0633, 2022-04-28 08:12:32, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(len(v))
check = np.sum(pos != v)
if check != 0:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
a = v[::-1]
return np.array(u+a)
def f3(M, v):
pass
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0634, 2022-04-28 08:15:03, PP- (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(len(v))
check = np.sum(pos != v)
if check != 0:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
a = v[::-1]
return np.array(u+a)
def f3(M, v):
A = []
A.append([M * v])
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0635, 2022-04-28 08:13:35, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i = np.arange(v.shape[0])
get = v == i
if False in get:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0636, 2022-04-28 08:16:42, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i = np.arange(v.shape[0])
get = v == i
if False in get:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array(u[:n]+v[n:-1:-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0637, 2022-04-28 08:16:59, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i = np.arange(v.shape[0])
get = v == i
if False in get:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array(u[:n]+v[n::-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0638, 2022-04-28 08:15:23, xxx (0%)
def f1(v):
a = np.arange(0,v.shape[0],1)
result = a == v
if np.sum(result) == v.shape[0]:
return True
else:
return False
np.array([1,2,3,4,5])
def f2(u, v):
v_reversed = v[::-1]
result = u + v_reversed
return result
def f3(M, v):
result = (M.T * v).T
return result
for k in range(int(input())):
exec(input().strip())
| # 0639, 2022-04-28 08:15:33, PPx (67%)
import numpy as np
def f1(v):
a = np.arange(0,v.shape[0],1)
result = a == v
if np.sum(result) == v.shape[0]:
return True
else:
return False
np.array([1,2,3,4,5])
def f2(u, v):
v_reversed = v[::-1]
result = u + v_reversed
return result
def f3(M, v):
result = (M.T * v).T
return result
for k in range(int(input())):
exec(input().strip())
| # 0640, 2022-04-28 08:15:56, PPx (67%)
import numpy as np
def f1(v):
a = np.arange(0,v.shape[0],1)
result = a == v
if np.sum(result) == v.shape[0]:
return True
else:
return False
np.array([1,2,3,4,5])
def f2(u, v):
v_reversed = v[::-1]
result = u + v_reversed
return result
def f3(M, v):
result = (M.T * v).T
return result
for k in range(int(input())):
exec(input().strip())
|
# 0641, 2022-04-28 08:07:53, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
k = np.arange(v.shape[0])
if (k.shape==v.shape) and np.sum(v!=k) == 0 :
return True
else :
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
i = np.arange(u.shape[0])
n = u.shape[0]
return u[i]+v[n-i-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0642, 2022-04-28 08:11:19, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
k = np.arange(v.shape[0])
if (k.shape==v.shape) and np.sum(v!=k) == 0 :
return True
else :
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
i = np.arange(u.shape[0])
n = u.shape[0]
return u[i]+v[n-i-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
i = np.arange(M.shape[0])
j = np.arange(M.shape[1])
A.append([M[i,j]*v[j]])
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0643, 2022-04-28 08:13:09, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
k = np.arange(v.shape[0])
if (k.shape==v.shape) and np.sum(v!=k) == 0 :
return True
else :
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
i = np.arange(u.shape[0])
n = u.shape[0]
return u[i]+v[n-i-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
i = np.arange(M.shape[0])
j = np.arange(M.shape[1])
A.append(M[i,j]*v[j])
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0644, 2022-04-28 08:14:30, -Px (33%)
import numpy as np
def f1(v) :
check = np.arange(0,v.shape[0],1)
if list(v[v==check]) != [True]*len(v) :
return False
else :
return True
def f2(u,v):
n = u.shape[0]
line = u + v[::-1]
return line
for k in range(int(input())):
exec(input().strip())
| # 0645, 2022-04-28 08:15:33, -PP (67%)
import numpy as np
def f1(v) :
check = np.arange(0,v.shape[0],1)
if list(v[v==check]) != [True]*len(v) :
return False
else :
return True
def f2(u,v):
n = u.shape[0]
line = u + v[::-1]
return line
def f3(M, v):
return M*v
for k in range(int(input())):
exec(input().strip())
|
# 0646, 2022-04-28 08:12:47, x-P (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
for i in range(v.shape[0]):
if v[i] != i: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u+v[::1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0647, 2022-04-28 08:13:12, xPP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
for i in range(v.shape[0]):
if v[i] != i: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u+v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0648, 2022-04-28 08:10:00, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
u = np.arange(0,v.shape[0])
x = u == v
return np.min(x)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0649, 2022-04-28 08:13:49, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
u = np.arange(0,v.shape[0])
x = u == v
return np.min(x)
def f2(u, v):
n = u.shape[0]
v = v[::-1]
x = u + v[:n]
return x
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0650, 2022-04-28 08:14:16, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
n = np.arange(v.shape[0])
if False in ( v[n] == n ) :
return False
else :
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
x = np.arange(n)
y = np.arange(n-1,-1,-1)
return u[x]+v[y]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
print(f1(np.array([0,1,2,3]))
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0651, 2022-04-28 08:14:48, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
n = np.arange(v.shape[0])
if False in ( v[n] == n ) :
return False
else :
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
x = np.arange(n)
y = np.arange(n-1,-1,-1)
return u[x]+v[y]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return []
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0652, 2022-04-28 08:08:41, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a=np.arange(v.shape[0])
b= v == a
if np.sum(b) ==v.shape[0]:
return True
else:
return False
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0653, 2022-04-28 08:13:21, PxP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a=np.arange(v.shape[0])
b= v == a
if np.sum(b) ==v.shape[0]:
return True
else:
return False
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M *v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0654, 2022-04-28 08:08:44, Pxx (33%)
import numpy as np
def f1(v):
test = np.arange(v.shape[0])
if (v == test).all() :
return True
return False
def f2(u, v):
pass
def f3(M, v):
pass
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0655, 2022-04-28 08:14:43, PPx (67%)
import numpy as np
def f1(v):
test = np.arange(v.shape[0])
if (v == test).all() :
return True
return False
def f2(u, v):
n = u.shape[0]
i = np.arange(n)
t = np.array(u[i]+v[n-i-1])
return np.array(t)
def f3(M, v):
pass
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0656, 2022-04-28 08:06:43, Pxx (33%)
import numpy as np
def f1(v):
r = np.arange(v.shape[0])
if np.sum(v == r) == v.shape[0]:
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0657, 2022-04-28 08:15:49, PPx (67%)
import numpy as np
def f1(v):
r = np.arange(v.shape[0])
if np.sum(v == r) == v.shape[0]:
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0658, 2022-04-28 08:12:59, Pxx (33%)
import numpy as np
def f1(v):
newv = np.array(v)
checki = np.arange(newv.shape[0])
condi = np.array([10]*newv.shape[0]) ** checki
if np.sum(newv*condi) != np.sum(checki*condi):
return False
else :
return True
def f2(u, v):
pass
def f3(M, v):
pass
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0659, 2022-04-28 08:14:12, PPx (67%)
import numpy as np
def f1(v):
newv = np.array(v)
checki = np.arange(newv.shape[0])
condi = np.array([10]*newv.shape[0]) ** checki
if np.sum(newv*condi) != np.sum(checki*condi):
return False
else :
return True
def f2(u, v):
newv = np.array(v)
newu = np.array(u)
ans = newu + newv[::-1]
return ans
def f3(M, v):
pass
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0660, 2022-04-28 08:14:30, PP- (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(0,v.shape[0])
x = v != pos
if np.sum(x) > 0:
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
a = np.arange(0,n)
return np.array(u[a]+v[a[::-1]])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
a = M + v
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0661, 2022-04-28 08:14:45, PP- (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
n = np.arange(v.shape[0])
if np.sum(v[v != n]) != 0:
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
a = np.arange(n)
b = np.arange(n-1,-1,-1)
return np.array(u[a]+v[b])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
A.append(M*v)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0662, 2022-04-28 08:14:33, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
# for i in range(v.shape[0]):
# if v[i] != i: return False
# return True
R = np.arange(0, v.shape[0])
# print(R)
A = v == R
# print(A)
Va = np.sum(A == False)
# print(Va)
if Va == 0 : return True
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
# n = u.shape[0]
# return np.array([u[i]+v[n-i-1] for i in range(n)])
# print(v[::-1],u[:])
return u[:] + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0663, 2022-04-28 08:13:33, P-P (67%)
#28/4/2022 test
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(len(v))
if v.sum(axis=0) == a.sum(axis=0):
return True
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
v1 = v[::-1]
return np.array([u+v1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return v*M
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0664, 2022-04-28 08:15:07, xPP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(0,v.shape[0])
if v!=a: return False
else: return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array(u+v[::-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.array(M*v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0665, 2022-04-28 08:11:02, -PP (67%)
import numpy as np
def f1(v):
a = np.arange(0,v.shape[0])
b = v[v==a]
return np.sum(b)==v.shape[0]
def f2(u, v):
return u+v[::-1]
def f3(M, v):
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0666, 2022-04-28 08:11:09, xPP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
for i in range(v.shape[0]):
if v[i] != i:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u + v[::-1]
return n
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = M*v
return A
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0667, 2022-04-28 08:12:38, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(0,v.shape[0])
return np.sum(v == a)==v.shape[0]
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u + v[::-1]
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0668, 2022-04-28 08:15:11, PPx (67%)
import numpy as np
def f1(v):
test = np.arange(len(v))
compare = (v == test)
# print(v)
# print(test)
# print(compare)
if np.sum(compare) != len(compare):
return False
return True
def f2(u,v):
a = np.array(u).reshape(1,u.shape[0])
b = np.array(v).reshape(1,v.shape[0])
b = b[:,::-1]
return (a+b).reshape(u.shape[0])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
pass
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0669, 2022-04-28 08:15:32, -PP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return np.array(u+v[::-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.array(M*v)
# ----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0670, 2022-04-28 08:14:32, xPP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(len(v)+1)
if v[:]!=a[:]:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
a = v[::-1]
ans = u+a
return ans
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
g = np.zeros_like (M, int)
g[:]=v
ans = g*M
return ans
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0671, 2022-04-28 08:14:26, PPx (67%)
import numpy as np
def f1(v):
x=np.arange(v.shape[0])
st=v[:]!=x[:]
if np.sum(st)!=0:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u[:]+v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0672, 2022-04-28 08:15:38, PPx (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
c = np.arange(v.shape[0])
if v[v == c].shape[0] == v.shape[0] :
return True
else :
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = np.arange(u.shape[0])
return np.array(u[n] + v[u.shape[0]-n-1])
# return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
# A = []
# for i in range(M.shape[0]):
# a = []
# for j in range(M.shape[1]):
# a.append(M[i,j] * v[j])
# A.append(a)
# return np.array(A)
return
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0673, 2022-04-28 08:12:41, -PP (67%)
import numpy as np
def f1(v):
chk = sum(v == np.arange(v.shape[0]))
if not chk:
return True
return False
def f2(u, v):
return u+v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
ans = M*v
return np.array(ans)
# ----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0674, 2022-04-28 08:11:00, PPx (67%)
import numpy as np
def f1(v):
num = np.arange(len(v))
a = num[v == num]
if len(a) == len(v) :return True
else: return False
def f2(u, v):
a = u + v[::-1]
return a
for k in range(int(input())):
exec(input().strip())
|
# 0675, 2022-04-28 08:15:59, PxP (67%)
import numpy as np
def f1(v):
# v: 1-D numpy array
# np.array([1,2,3,4,5]) shape[0] = 5
# idx_row = np.max(new_board,axis = 1) == 0
index = np.arange(v.shape[0])
v = v == index
out = not(False in v)
return out
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
return M * v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0676, 2022-04-28 08:04:34, --- (0%)
def f1(v):
v = v==i
if np.min(v)==0:
return 0
else:
return 1
| # 0677, 2022-04-28 08:06:19, --- (0%)
import numpy as np
def f1(v):
v = v==i
if np.min(v)==0:
return 0
else:
return 1
| # 0678, 2022-04-28 08:06:38, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
for i in range(v.shape[0]):
if v[i] != i: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
def f1(v):
v = v==i
if np.min(v)==0:
return 0
else:
return 1
| # 0679, 2022-04-28 08:07:27, --- (0%)
def f1(v):
v = v==i
if np.min(v)==0:
return 0
else:
return 1
def f2(u, v):
r = u[::]+v[::-1]
return r
| # 0680, 2022-04-28 08:07:39, --- (0%) def f2(u, v): r = u[::]+v[::-1] return r | # 0681, 2022-04-28 08:08:05, xxx (0%) def f2(u, v): r = u[::]+v[::-1] return r for k in range(int(input())): exec(input().strip()) | # 0682, 2022-04-28 08:08:34, compilation error (0%) def f2(u, v): r = u[::]+v[::-1] return r for k in range(int(input())): exec(input().strip()) | # 0683, 2022-04-28 08:09:17, compilation error (0%) def f2(u, v): r = u[::]+v[::-1] return r for k in range(int(input())): exec(input().strip()) | # 0684, 2022-04-28 08:11:22, xxx (0%)
def f1(v):
v = v==i
if np.min(v)==0:
return 0
else:
return 1
def f2(u, v):
r = u[::]+v[::-1]
return r
for k in range(int(input())):
exec(input().strip())
| # 0685, 2022-04-28 08:12:14, xPx (33%)
import numpy as np
def f1(v):
v = v==i
if np.min(v)==0:
return 0
else:
return 1
def f2(u, v):
r = u[::]+v[::-1]
return r
for k in range(int(input())):
exec(input().strip())
| # 0686, 2022-04-28 08:16:35, xPx (33%)
import numpy as np
def f1(v):
v = v==i
if np.min(v)==0:
return 0
else:
return 1
def f2(u, v):
r = u[::]+v[::-1]
return r
for k in range(int(input())):
exec(input().strip())
|
# 0687, 2022-04-28 08:01:49, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
for i in range(v.shape[0]):
if v[i] != i: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0688, 2022-04-28 08:05:22, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
for i in range(v.shape[0]):
if v[i] != i: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0689, 2022-04-28 08:10:09, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return np.sum(v) == np.sum(np.arange(v.shape[0]))
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0690, 2022-04-28 08:10:22, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return np.sum(v) == np.sum(np.arange(v.shape[0]))
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0691, 2022-04-28 08:12:05, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return np.sum(v) == np.sum(np.arange(v.shape[0]))
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
nn = np.arange(n)
return np.array(u[n] + v[n-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0692, 2022-04-28 08:12:17, P-x (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return np.sum(v) == np.sum(np.arange(v.shape[0]))
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
nn = np.arange(n)
return np.array(u[nn] + v[nn-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0693, 2022-04-28 08:12:46, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return np.sum(v) == np.sum(np.arange(v.shape[0]))
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
nn = np.arange(n)
return np.array(u[nn] + v[nn-n-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0694, 2022-04-28 08:13:16, P-x (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return np.sum(v) == np.sum(np.arange(v.shape[0]))
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
nn = np.arange(n)
return np.array(u[nn] + v[nn-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0695, 2022-04-28 08:15:10, P-x (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return np.sum(v) == np.sum(np.arange(v.shape[0]))
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
nn = np.arange(n)
return np.array(u[nn] + v[nn-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0696, 2022-04-28 08:16:14, P-x (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return np.sum(v) == np.sum(np.arange(v.shape[0]))
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
nn = np.arange(n)
return np.array(u[nn] + v[nn-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0697, 2022-04-28 08:02:25, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
for i in range(v.shape[0]):
if v[i] != i: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0698, 2022-04-28 08:04:47, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i = np.arange(0,x.shape[0])
#for i in range(v.shape[0]):
if v[i] != i: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0699, 2022-04-28 08:07:55, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i = np.arange(0,v.shape[0])
#for i in range(v.shape[0]):
if v[i] != i: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0700, 2022-04-28 08:10:28, xPx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i = np.arange(0,v.shape[0])
#for i in range(v.shape[0]):
if v[i] != i: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
#return np.array([u[i]+v[n-i-1] for i in range(n)])
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0701, 2022-04-28 08:11:58, xPx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i = np.arange(0,v.shape[1])
#for i in range(v.shape[0]):
if v[i] != i: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
#return np.array([u[i]+v[n-i-1] for i in range(n)])
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0702, 2022-04-28 08:12:10, xPx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i = np.arange(v.shape[0])
#for i in range(v.shape[0]):
if v[i] != i: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
#return np.array([u[i]+v[n-i-1] for i in range(n)])
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0703, 2022-04-28 08:15:33, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i = np.arange(0,v.shape[0])
#for i in range(v.shape[0]):
#if v[i] != i: return False
if np.sum(v[i] != i) != 0 return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
#return np.array([u[i]+v[n-i-1] for i in range(n)])
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0704, 2022-04-28 08:16:42, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i = np.arange(0,v.shape[0])
#for i in range(v.shape[0]):
#if v[i] != i: return False
if np.sum(v[i] != i) != 0 return True
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
#return np.array([u[i]+v[n-i-1] for i in range(n)])
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0705, 2022-04-28 08:17:08, -Px (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i = np.arange(0,v.shape[0])
#for i in range(v.shape[0]):
#if v[i] != i: return False
if np.sum(v[i] != i) != 0 : return True
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
#return np.array([u[i]+v[n-i-1] for i in range(n)])
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0706, 2022-04-28 08:04:29, --- (0%)
import numpy as np
def f1(v):
check = np.sum(v)
if check != 0:
return False
else:
return True
| # 0707, 2022-04-28 08:04:46, --- (0%)
import numpy as np
def f1(v):
check = np.sum(v)
if check != 0:
return False
else:
return True
exec(input().strip())
| # 0708, 2022-04-28 08:05:12, compilation error (0%)
import numpy as np
def f1(v):
check = np.sum(v)
if check != 0:
return False
else:
return True
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())())
| # 0709, 2022-04-28 08:05:32, compilation error (0%)
import numpy as np
def f1(v):
check = np.sum(v)
if check != 0:
return False
else:
return True
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())())
| # 0710, 2022-04-28 08:12:12, compilation error (0%)
import numpy as np
def f1(v):
check = np.sum(v)
if check != 0:
return False
else:
return True
def f2(u,v):
n = u.shape[0]
return np.array(u[0::1]+v[-1::-1])
exec(input().strip())())
| # 0711, 2022-04-28 08:13:03, --- (0%)
import numpy as np
def f1(v):
check = np.sum(v)
if check != 0:
return False
else:
return True
def f2(u,v):
n = u.shape[0]
return np.array(u[0::1]+v[-1::-1])
| # 0712, 2022-04-28 08:13:28, -Px (33%)
import numpy as np
def f1(v):
check = np.sum(v)
if check != 0:
return False
else:
return True
def f2(u,v):
n = u.shape[0]
return np.array(u[0::1]+v[-1::-1])
for k in range(int(input())):
exec(input().strip())
|
# 0713, 2022-04-28 08:07:40, -xx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[0:i+1]+v[0:n-i] ])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0714, 2022-04-28 08:11:36, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
b=a!=[0:v.shape(1)]
c=sum(b)
if c>=1:
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[0:i+1]+v[0:n-i] ])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0715, 2022-04-28 08:12:16, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
b=a!=np.array([0:v.shape(1)])
c=sum(b)
if c>=1:
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[0:i+1]+v[0:n-i] ])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0716, 2022-04-28 08:13:17, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
b=a!=np.array([0,v.shape(1)])
c=sum(b)
if c>=1:
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[0:i+1]+v[0:n-i] ])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0717, 2022-04-28 08:14:40, xxP (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
b=a!=np.array([0,v.shape(1)])
c=sum(b)
if c>=1:
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[0:i+1]+v[0:n-i] ])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.array(M*v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0718, 2022-04-28 08:15:19, xxP (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
b=a!=np.array([0,v.shape(1)])
c=sum(b)
if c>=1:
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[0,i+1]+v[0,n-i] ])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.array(M*v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0719, 2022-04-28 08:16:45, x-P (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
b=a!=np.array([0,v.shape(1)])
c=sum(b)
if c>=1:
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array(u+v)
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.array(M*v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0720, 2022-04-28 08:07:52, x-x (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
ncol = v.shape[1]
f1 = v[::]==np.arange(ncol)
return f1
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
f2 = np.array([u[::]+v[::-1]])
return f2
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
'''
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
'''
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0721, 2022-04-28 08:11:48, x-x (0%) import numpy as np def f1(v): # v: 1-D numpy array ncol = v.shape[1] f1 = v[::]==np.arange(ncol) return f1 def f2(u, v): # u and v are 1-D numpy array of equal size n = u.shape[0] f2 = np.array([u[::]+v[::-1]]) return f2 def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] a = M[i,j] * v[j] A = np.ones((M.shape[0],M.shape[1]),int) f3 = A*a return A #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0722, 2022-04-28 08:13:40, xPx (33%) import numpy as np def f1(v): # v: 1-D numpy array ncol = v.shape[1] f1 = v[::]==np.arange(ncol) return f1 def f2(u, v): # u and v are 1-D numpy array of equal size n = u.shape[0] f2 = u[::]+v[::-1] return f2 def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] a = M[i,j] * v[j] A = np.ones((M.shape[0],M.shape[1]),int) f3 = A*a return A #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0723, 2022-04-28 08:14:44, xPx (33%) import numpy as np def f1(v): # v: 1-D numpy array ncol = v.shape[1] f1 = v[::]==np.arange(ncol) return f1 def f2(u, v): # u and v are 1-D numpy array of equal size n = u.shape[0] f2 = u[::]+v[::-1] return f2 def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] nrowM = M.shape[0] nrowv = v.shape[0] a = M[:] * v[nrowv] A = np.ones((M.shape[0],M.shape[1]),int) f3 = A*a return A #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0724, 2022-04-28 08:15:06, xPx (33%) import numpy as np def f1(v): # v: 1-D numpy array ncol = v.shape[1] f1 = v[::]==np.arange(ncol) return f1 def f2(u, v): # u and v are 1-D numpy array of equal size n = u.shape[0] f2 = u[::]+v[::-1] return f2 def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] nrowM = M.shape[0] nrowv = v.shape[0] a = M[:] * v[nrowv] #A = np.ones((M.shape[0],M.shape[1]),int) #f3 = A*a return a #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0725, 2022-04-28 08:16:03, xPx (33%) import numpy as np def f1(v): # v: 1-D numpy array ncol = v.shape[1] f1 = v[::]==np.arange(ncol) if np.sum(f1)==0: return True return False def f2(u, v): # u and v are 1-D numpy array of equal size n = u.shape[0] f2 = u[::]+v[::-1] return f2 def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] nrowM = M.shape[0] nrowv = v.shape[0] a = M[:] * v[nrowv] #A = np.ones((M.shape[0],M.shape[1]),int) #f3 = A*a return a #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0726, 2022-04-28 08:16:49, xPx (33%) import numpy as np def f1(v): # v: 1-D numpy array ncol = v.shape[1] f1 = v[::]==np.arange(ncol) f1 = f1==False if np.sum(f1)==0: return True return False def f2(u, v): # u and v are 1-D numpy array of equal size n = u.shape[0] f2 = u[::]+v[::-1] return f2 def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] nrowM = M.shape[0] nrowv = v.shape[0] a = M[:] * v[nrowv] #A = np.ones((M.shape[0],M.shape[1]),int) #f3 = A*a return a #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) |
# 0727, 2022-04-28 08:04:18, compilation error (0%) import numpy as np def f1(v): # v: 1-D numpy array for i in range(v.shape[0]): if v[i] != i: return False return True def f2(u, v): # u and v are 1-D numpy array of equal size n = u.shape[0] return np.array([u[i]+v[n-i-1] for i in range(n)]) def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] A = [] for i in range(M.shape[0]): a = [] for j in range(M.shape[1]): a.append(M[i,j] * v[j]) A.append(a) return np.array(A) #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0728, 2022-04-28 08:08:11, compilation error (0%) import numpy as np def f1(v): # v: 1-D numpy array for i in range(v.shape[0]): if v[i] != i: return False return True def f2(u, v): # u and v are 1-D numpy array of equal size n = u.shape[0] return np.array([u[i]+v[n-i-1] for i in range(n)]) def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] A = [] for i in range(M.shape[0]): a = [] for j in range(M.shape[1]): a.append(M[i,j] * v[j]) A.append(a) return np.array(A) #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0729, 2022-04-28 08:12:52, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x = np.arange(0,v.shape[0],1)
if v[x] != x :return False
return True
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0730, 2022-04-28 08:13:12, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x = np.arange(0,v.shape[0],1)
if v[x] != x :return False
return False
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0731, 2022-04-28 08:13:25, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x = np.arange(0,v.shape[0],1)
if v[x] != x :return True
return False
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0732, 2022-04-28 08:15:23, xxP (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x = np.arange(0,v.shape[0],1)
if v[x] != x :return True
return False
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1] M = [[1,2],[3,4],[5,6]] v = [1,2]
z = M * v
return z
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0733, 2022-04-28 08:16:24, -xP (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x = np.arange(0,v.shape[0],1)
r = np.array(x==v)
if False :return False
return True
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1] M = [[1,2],[3,4],[5,6]] v = [1,2]
z = M * v
return z
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0734, 2022-04-28 08:08:31, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.array(list(range(v.shape[0])))
return v.shape == a.shape and np.sum(v!=a)==0
| # 0735, 2022-04-28 08:11:51, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.array(list(range(v.shape[0])))
return v.shape == a.shape and np.sum(v!=a)==0
for k in range(int(input())):
exec(input().strip())
| # 0736, 2022-04-28 08:13:34, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.array(list(range(v.shape[0])))
return v.shape == a.shape and np.sum(v!=a)==0
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = np.array(list(range(u.shape[0])))
m = (u.shape[0]-1)-n
return np.array([u[n]+v[m]
for k in range(int(input())):
exec(input().strip())
| # 0737, 2022-04-28 08:13:54, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.array(list(range(v.shape[0])))
return v.shape == a.shape and np.sum(v!=a)==0
for k in range(int(input())):
exec(input().strip())
| # 0738, 2022-04-28 08:14:24, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.array(list(range(v.shape[0])))
return v.shape == a.shape and np.sum(v!=a)==0
for k in range(int(input())):
exec(input().strip())
| # 0739, 2022-04-28 08:15:22, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.array(list(range(v.shape[0])))
return v.shape == a.shape and np.sum(v!=a)==0
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0] #แถว
return np.array([u[i]+v[n-i-1] for i in range(n)])
n = np.array(list(range(u.shape[0])))
m = (u.shape[0]-1)-n
return np.array([u[n]+v[m]])
for k in range(int(input())):
exec(input().strip())
| # 0740, 2022-04-28 08:15:49, P-x (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.array(list(range(v.shape[0])))
return v.shape == a.shape and np.sum(v!=a)==0
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = np.array(list(range(u.shape[0])))
m = (u.shape[0]-1)-n
return np.array([u[n]+v[m]])
for k in range(int(input())):
exec(input().strip())
|
# 0741, 2022-04-28 08:10:07, --P (33%) import numpy as np def f1(v): if v[0] != 1: return False return True def f2(u, v): return u+(v-1) def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] return M*v #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0742, 2022-04-28 08:11:38, --P (33%) import numpy as np def f1(v): if v[0] != 1: return False return True def f2(u, v): return u+v def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] return M*v #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0743, 2022-04-28 08:14:34, x-P (33%) import numpy as np def f1(v): if v.shape[1] != 1: return False return True def f2(u, v): return u+v def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] return M*v #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0744, 2022-04-28 08:15:36, xxP (33%) import numpy as np def f1(v): if v.shape[1] != 1: return False return True def f2(u, v): return u+v[1:] def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] return M*v #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0745, 2022-04-28 08:15:45, -xP (33%) import numpy as np def f1(v): if v.shape[0] != 1: return False return True def f2(u, v): return u+v[1:] def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] return M*v #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0746, 2022-04-28 08:16:14, xxP (33%) import numpy as np def f1(v): if v!= 0: return False return True def f2(u, v): return u+v[1:] def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] return M*v #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0747, 2022-04-28 08:17:13, xxP (33%) import numpy as np def f1(v): if v!= 0: return False return True def f2(u, v): return u+v[1::] def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] return M*v #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) |
# 0748, 2022-04-28 08:14:16, compilation error (0%)
import numpy as np
def f1(v):
a = v.shape[0]
b = np.arange(a)
c = v==b
if np.sum(c) == a :
return True
else :
return False
def f2(u, v):
n = u.shape[0]
k = v.shape[0]
j = v[::-1]
q = u+v
return q
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1] A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j]) A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0749, 2022-04-28 08:14:31, compilation error (0%)
import numpy as np
def f1(v):
a = v.shape[0]
b = np.arange(a)
c = v==b
if np.sum(c) == a :
return True
else :
return False
def f2(u, v):
n = u.shape[0]
k = v.shape[0]
j = v[::-1]
q = u+v
return q
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1] A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j]) A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0750, 2022-04-28 08:15:19, P-x (33%)
import numpy as np
def f1(v):
a = v.shape[0]
b = np.arange(a)
c = v==b
if np.sum(c) == a :
return True
else :
return False
def f2(u, v):
n = u.shape[0]
k = v.shape[0]
j = v[::-1]
q = u+v
return q
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1] A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0751, 2022-04-28 08:16:27, P-x (33%)
import numpy as np
def f1(v):
a = v.shape[0]
b = np.arange(a)
c = v==b
if np.sum(c) == a :
return True
else :
return False
def f2(u, v):
n = u.shape[0]
k = v.shape[0]
j = v[::-1]
q = u+v
return q
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1] A = []
A = np.dot(v,M)
return A
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0752, 2022-04-28 08:16:30, P-x (33%)
import numpy as np
def f1(v):
a = v.shape[0]
b = np.arange(a)
c = v==b
if np.sum(c) == a :
return True
else :
return False
def f2(u, v):
n = u.shape[0]
k = v.shape[0]
j = v[::-1]
q = u+v
return q
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1] A = []
A = np.dot(v,M)
return A
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0753, 2022-04-28 08:17:14, P-x (33%)
import numpy as np
def f1(v):
a = v.shape[0]
b = np.arange(a)
c = v==b
if np.sum(c) == a :
return True
else :
return False
def f2(u, v):
n = u.shape[0]
k = v.shape[0]
j = v[::-1]
q = u+v
return q
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1] A = []
A = np.dot(v,M)
return A
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0754, 2022-04-28 08:06:12, -xx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return np.sum(v[:]!=np.arange(v.shape[0]))!=0
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0755, 2022-04-28 08:06:39, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return np.sum(v[:,:]!=np.arange(v.shape[0]))!=0
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0756, 2022-04-28 08:10:51, -x- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return np.sum(v[:]!=np.arange(v.shape[0]))!=0
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
a = M[:,:]*v[:]
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0757, 2022-04-28 08:12:13, Px- (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return np.sum(v[:]!=np.arange(v.shape[0]))==0
def f2(u, v):
pass
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
a = M[:,:]*v[:]
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0758, 2022-04-28 08:13:16, Px- (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return np.sum(v[:]!=np.arange(v.shape[0]))==0
def f2(u, v):
pass
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
s = v.T
a = M[:,:]*s[:]
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0759, 2022-04-28 08:15:12, Px- (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return np.sum(v[:]!=np.arange(v.shape[0]))==0
def f2(u, v):
pass
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
s = v.T
a = np.sum(M[:,:]*s[:] ,axis =1)
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0760, 2022-04-28 08:04:50, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return v[:v.shape[0] == i]
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0761, 2022-04-28 08:07:21, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if v[:v.shape[0] != i] == True :
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0762, 2022-04-28 08:09:38, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if v[:v.shape[0] != i] == True :
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
ans = np.dot(M,V)
return ans
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0763, 2022-04-28 08:10:48, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if v[:v.shape[0]] != i :
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
ans = np.dot(M,V)
return ans
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0764, 2022-04-28 08:13:25, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if v[:v.shape[0]] != i :
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
ans = u[i] + v[::-1]
return ans
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
ans = np.dot(M,V)
return ans
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0765, 2022-04-28 08:14:04, xPx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if v[:v.shape[0]] != i :
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
ans = u + v[::-1]
return ans
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
ans = M*V
return ans
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0766, 2022-04-28 08:12:26, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if v[0:v.shape[0]] != v.shape[0]:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
np.array([u[i]+v[n-i-1]])
return []
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0767, 2022-04-28 08:14:48, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if v[0:v.shape[0]] != v.shape[0]:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
np.array(u+v[::-1])
return []
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a=list(M[i,j] * v[0:M.shape[1]])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0768, 2022-04-28 08:15:22, xPx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if v[0:v.shape[0]] != v.shape[0]:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return np.array(u+v[::-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a=list(M[i,j] * v[0:M.shape[1]])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0769, 2022-04-28 08:16:14, xPx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if v[0:v.shape[0]] != v.shape[0]:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return np.array(u+v[::-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0770, 2022-04-28 08:17:03, -Px (33%) import numpy as np def f1(v): # v: 1-D numpy array pass def f2(u, v): # u and v are 1-D numpy array of equal size return np.array(u+v[::-1]) def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] pass #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) |
# 0771, 2022-04-28 08:12:56, --P (33%)
import numpy as np
def f1(v):
return np.arange(v.shape[0])==v
def f2(u,v):
return u[::-1]+v
def f3(M, v):
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0772, 2022-04-28 08:13:28, --P (33%)
import numpy as np
def f1(v):
return np.arange(v.shape[0])+1==v
def f2(u,v):
return u[::-1]+v
def f3(M, v):
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0773, 2022-04-28 08:15:04, --P (33%)
import numpy as np
def f1(v):
return np.arange(v.shape[0])+1==v
def f2(u,v):
return u[::-1]+v
def f3(M, v):
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0774, 2022-04-28 08:16:17, compilation error (0%)
import numpy as np
def f1(v):
return np.arange(v.shape[0])+1==v
def f2(u,v):
n = u.shape[0]
i = np.arange(n)
return np.array(u[i]+v[n-i-1]
def f3(M, v):
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0775, 2022-04-28 08:16:47, --P (33%)
import numpy as np
def f1(v):
return np.arange(v.shape[0])==v
def f2(u,v):
return u[::-1]+v
def f3(M, v):
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0776, 2022-04-28 08:09:42, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
# for i in range(v.shape[0]):
# if v[i] != i:
# return False
# return True
return h[:,1]
def f2(u, v):
# u and v are 1-D numpy array of equal size (1,3)
# n = u.shape[0] # n = 3
# return np.array([u[i]+v[n-i-1] for i in range(n)]) 1+6, 2 + 5
return u + v
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
# for k in range(int(input())):
# exec(input().strip())
| # 0777, 2022-04-28 08:10:53, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
# for i in range(v.shape[0]):
# if v[i] != i:
# return False
# return True
return h[:,1]
def f2(u, v):
# u and v are 1-D numpy array of equal size (1,3)
# n = u.shape[0] # n = 3
# return np.array([u[i]+v[n-i-1] for i in range(n)]) 1+6, 2 + 5
return u + v
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
# for k in range(int(input())):
# exec(input().strip())
| # 0778, 2022-04-28 08:12:39, x-x (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
# for i in range(v.shape[0]):
# if v[i] != i:
# return False
# return True
return h[:,1]
def f2(u, v):
# u and v are 1-D numpy array of equal size (1,3)
# n = u.shape[0] # n = 3
# return np.array([u[i]+v[n-i-1] for i in range(n)]) 1+6, 2 + 5
return u + v
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0779, 2022-04-28 08:14:19, x-P (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
# for i in range(v.shape[0]):
# if v[i] != i:
# return False
# return True
return h[:,1]
def f2(u, v):
# u and v are 1-D numpy array of equal size (1,3)
# n = u.shape[0] # n = 3
# return np.array([u[i]+v[n-i-1] for i in range(n)]) 1+6, 2 + 5
return u + v
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0780, 2022-04-28 08:15:07, --P (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
# for i in range(v.shape[0]):
# if v[i] != i:
# return False
# return True
return
def f2(u, v):
# u and v are 1-D numpy array of equal size
# n = u.shape[0] # n = 3
# return np.array([u[i]+v[n-i-1] for i in range(n)])
return u + v
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0781, 2022-04-28 08:07:58, -xP (33%)
import numpy as np
def f1(v):
d = np.arange(1,v.shape[0]+1)
return v == d
def f2(u,v):
return u + v[:,-1::-1]
def f3(M,v):
return M*v
for k in range(int(input())):
exec(input().strip())
| # 0782, 2022-04-28 08:09:24, -xP (33%)
import numpy as np
def f1(v):
d = np.arange(1,v.shape[0]+1)
return v == d
def f2(u,v):
return u + v[:,v.shape[1]-1::-1]
def f3(M,v):
return M*v
for k in range(int(input())):
exec(input().strip())
| # 0783, 2022-04-28 08:11:10, xxP (33%)
import numpy as np
def f1(v):
d = np.arange((1,v.shape[0]+1))
return v == d
def f2(u,v):
return u + v[:,v.shape[1]-1::-1]
def f3(M,v):
return M*v
for k in range(int(input())):
exec(input().strip())
| # 0784, 2022-04-28 08:12:09, xxP (33%)
import numpy as np
def f1(v):
d = np.arange((1,v.shape[0]+1))
if np.sum(d-v) == 0:
return True
return False
def f2(u,v):
return u + v[:,v.shape[1]-1::-1]
def f3(M,v):
return M*v
for k in range(int(input())):
exec(input().strip())
| # 0785, 2022-04-28 08:14:39, -xP (33%)
import numpy as np
def f1(v):
d = np.arange(1,v.shape[0]+1,1)
if np.sum(d-v) == 0:
return True
return False
def f2(u,v):
return u + v[:,v.shape[1]-1::-1]
def f3(M,v):
return M*v
for k in range(int(input())):
exec(input().strip())
|
# 0786, 2022-04-28 08:07:08, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
ch = np.arange(v.shape[0])
if ch[:] != v[:]:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
print(np.arange(8))
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0787, 2022-04-28 08:07:54, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
ch = np.arange(v.shape[0])
if ch[:] != v[:]:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0788, 2022-04-28 08:11:31, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
ch = np.arange(v.shape[0])
f = ch != v
if True in f:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0789, 2022-04-28 08:15:41, P-x (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
ch = np.arange(v.shape[0])
f = ch != v
if True in f:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[:]+v[::-1]])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0790, 2022-04-28 08:16:51, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
ch = np.arange(v.shape[0])
f = ch != v
if True in f:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[:]+v[::-2]])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0791, 2022-04-28 08:11:29, xPx (33%)
import numpy as np
def f1(v):
la=len(v)
b=np.arange(la+1)
if np.mean(b[1:])==np.mean(a):
return False
else: return True
def f2(u, v):
b=u+v[::-1]
return b
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0792, 2022-04-28 08:14:45, -Px (33%)
import numpy as np
def f1(v):
la=len(v)
b=np.arange(la+1)
if v in b:
return False
else: return True
def f2(u, v):
b=u+v[::-1]
return b
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0793, 2022-04-28 08:15:01, -Px (33%)
import numpy as np
def f1(v):
la=len(v)
b=np.arange(la+1)
if v in b:
return False
else: return True
def f2(u, v):
b=u+v[::-1]
return b
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0794, 2022-04-28 08:15:32, -Px (33%)
import numpy as np
def f1(v):
la=len(v)
b=np.arange(la+1)
if v in b:
return False
else: return True
def f2(u, v):
b=u+v[::-1]
return b
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
pass
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0795, 2022-04-28 08:16:06, -Px (33%)
import numpy as np
def f1(v):
la=len(v)
b=np.arange(la+1)
if v in b:
return False
else: return True
def f2(u, v):
b=u+v[::-1]
return b
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
pass
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0796, 2022-04-28 08:06:18, P-x (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i = np.arange(0, v.shape[0], 1)
if np.sum(v) != np.sum(i) :return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
i = np.arange(0, n, 1)
return np.array([u[i]+v[n-i-1]])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
i = np.arange(0, M.shape[0], 1)
a = []
j = np.arange(0, M.shape[1], 1)
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0797, 2022-04-28 08:10:47, P-x (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i = np.arange(0, v.shape[0], 1)
if np.sum(v) != np.sum(i) :return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
i = np.arange(0, n, 1)
j = (np.ones((1,u.shape[0]) ,int)*n) - (i-1)
return np.array([u[i]+v[n-i-1]])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
i = np.arange(0, M.shape[0], 1)
a = []
j = np.arange(0, M.shape[1], 1)
a.append(M[i,j] * v[j])
A.append(a)
if a !=[]: a= []
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0798, 2022-04-28 08:13:20, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i = np.arange(0, v.shape[0], 1)
if np.sum(v) != np.sum(i) :return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
i = np.arange(0, n, 1)
j = (np.ones((1,u.shape[0]) ,int)*n) - (i-1)
return np.array([u[i]+v[j]])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
i = np.arange(0, M.shape[0], 1)
a = []
j = np.arange(0, M.shape[1], 1)
a.append(M[i,j] * v[j])
A.append(a)
if a !=[]: a= []
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0799, 2022-04-28 08:14:36, P-x (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i = np.arange(0, v.shape[0], 1)
if np.sum(v) != np.sum(i) :return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
i = np.arange(0, n, 1)
j = (np.ones((1,u.shape[0]) ,int)*n) - i-1
return np.array([u[i]+v[j]])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
i = np.arange(0, M.shape[0], 1)
a = []
j = np.arange(0, M.shape[1], 1)
a.append(M[i,j] * v[j])
A.append(a)
if a !=[]: a= []
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0800, 2022-04-28 08:16:57, P-x (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i = np.arange(0, v.shape[0], 1)
if np.sum(v) != np.sum(i) :return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
i = np.arange(0, n, 1)
#j = (np.ones((1,u.shape[0]) ,int)*n) - i-1
return np.array([u[i]+v[n-i-1]])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
i = np.arange(0, M.shape[0], 1)
a = []
j = np.arange(0, M.shape[1], 1)
a.append(M[i,j] * v[j])
A.append(a)
if a !=[]: a= []
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0801, 2022-04-28 08:10:20, -Px (33%) import numpy as np def f1(v): a = np.arange(0,v.shape[0],1) return v[v[a]==a] def f2(u, v): n = u.shape[0] a = np.arange(0,n,1) return np.array(u[a]+v[n-a-1]) def f3(M, v): A = [] a = [] i = np.arange(0,M.shape[0],1) j = np.arange(0,M.shape[1],1) a.append(M[i,j] * v[j]) A.append(a) return np.array(A) for k in range(int(input())): exec(input().strip()) | # 0802, 2022-04-28 08:10:33, -Px (33%) import numpy as np def f1(v): a = np.arange(0,v.shape[0],1) return v[v[a]==a] def f2(u, v): n = u.shape[0] a = np.arange(0,n,1) return np.array(u[a]+v[n-a-1]) def f3(M, v): A = [] a = [] i = np.arange(0,M.shape[0],1) j = np.arange(0,M.shape[1],1) a.append(M[i,j] * v[j]) A.append(a) return np.array(A) for k in range(int(input())): exec(input().strip()) | # 0803, 2022-04-28 08:11:23, -Px (33%) import numpy as np def f1(v): a = np.arange(0,v.shape[0],1) return v[v[a]==a] def f2(u, v): n = u.shape[0] a = np.arange(0,n,1) return np.array(u[a]+v[n-a-1]) def f3(M, v): A = [] a = [] i = np.arange(0,M.shape[0],1) j = np.arange(0,M.shape[1],1) a.append(M[i,j] * v[j]) A.append(a) return np.array(A) for k in range(int(input())): exec(input().strip()) | # 0804, 2022-04-28 08:15:07, -Px (33%) import numpy as np def f1(v): a = np.arange(0,v.shape[0],1) return v[v[a]==a] def f2(u, v): n = u.shape[0] a = np.arange(0,n,1) return np.array(u[a]+v[n-a-1]) def f3(M, v): A = [] a = [] i = np.arange(0,M.shape[0],1) j = np.arange(0,M.shape[1],1) a.append(M[i,j] * v[j]) A.append(a) return np.array(A) #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) |
# 0805, 2022-04-28 08:08:02, xxP (33%)
import numpy as np
def f1(v):
n = nd.arange(0,v.shape[0])
return v[v==i]
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0806, 2022-04-28 08:08:59, xxP (33%)
import numpy as np
def f1(v):
n = nd.arange(0,v.shape[0])
return v==i
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0807, 2022-04-28 08:14:05, -xP (33%)
import numpy as np
def f1(v):
n = np.arange(0,v.shape[0])
return v == n
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = np.arange(0,u.shape[0])
k = np.arange(n-i-1,0,-1)
return np.array([u[n]+v[k]])
def f3(M, v):
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0808, 2022-04-28 08:15:17, -xP (33%)
import numpy as np
def f1(v):
n = np.arange(0,v.shape[0])
return v[n] == n
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = np.arange(0,u.shape[0])
k = np.arange(n-i-1,0,-1)
return np.array([u[n]+v[k]])
def f3(M, v):
return M*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0809, 2022-04-28 08:07:15, xxP (33%)
import numpy as np
def f1(v):
a = np.arange(v.shape[0])
if np.sum(v = a) == v.shape[0] :
return True
else :
return False
def f2(u, v):
w = v[::_1]
return u + v
def f3(M, v):
return M * v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0810, 2022-04-28 08:09:58, xxP (33%)
import numpy as np
def f1(v):
a = np.arange(v.shape[0])
if np.sum(v = a) == v.shape[0] :
return True
else :
return False
def f2(u, v):
w = v[::_1]
return u + w
def f3(M, v):
return M * v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0811, 2022-04-28 08:12:21, xxP (33%)
import numpy as np
def f1(v):
v = np.array(v)
a = np.arange(v.shape[0])
if np.sum(v = a) == v.shape[0] :
return True
else :
return False
def f2(u, v):
w = v[::_1]
return u + w
def f3(M, v):
return M * v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0812, 2022-04-28 08:14:37, xxP (33%)
import numpy as np
def f1(v):
a = np.arange(v.shape[0])
if np.sum(v = a) == v.shape[0] :
return True
else :
return False
def f2(u, v):
w = v[::_1]
return u + w
def f3(M, v):
return M * v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0813, 2022-04-28 08:11:44, P-x (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
n = np.arange(0,v.shape[0])
b = v==n
if False in b:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
#n = u.shape[0]
#return np.array([u[i]+v[n-i-1] for i in range(n)])
v = v[::-1]
u += v
return u
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0814, 2022-04-28 08:14:25, P-x (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
n = np.arange(0,v.shape[0])
b = v==n
if False in b:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
#n = u.shape[0]
#return np.array([u[i]+v[n-i-1] for i in range(n)])
v = v[::-1]
u += v
return u
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
#A = []
#for i in range(M.shape[0]):
# a = []
# for j in range(M.shape[1]):
# a.append(M[i,j] * v[j])
# A.append(a)
#return np.array(A)
A = np.dot(v,M)
return A
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0815, 2022-04-28 08:15:13, P-x (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
n = np.arange(0,v.shape[0])
b = v==n
if False in b:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
v = v[::-1]
u += v
return u
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return A
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0816, 2022-04-28 08:16:17, P-x (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
n = np.arange(0,v.shape[0])
b = v==n
if False in b:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
v = v[::-1]
u += v
return u
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = np.dot(v,M)
return A
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0817, 2022-04-28 08:10:13, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(0,v.shape[0])
if False not in (v[:] == pos[:]):
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0818, 2022-04-28 08:10:27, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(0,v.shape[0])
if False not in (v[:] == pos[:]):
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0819, 2022-04-28 08:14:27, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(0,v.shape[0])
if False not in (v[:,:] == pos[:,:]):
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0820, 2022-04-28 08:15:42, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(0,v.shape[0])
if False not in (v[:] == pos[:]):
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0821, 2022-04-28 08:08:19, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
for i in range(v.shape[0]):
if v[i] != i: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
x=np.array(v)[::-1]
result=u+x
return result
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
| # 0822, 2022-04-28 08:09:41, xPx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
for i in range(v.shape[0]):
if v[i] != i: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
x=np.array(v)[::-1]
result=u+x
return result
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0823, 2022-04-28 08:12:24, xPx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
for i in range(v.shape[0]):
if v[i] != i: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
x=np.array(v)[::-1]
result=u+x
return result
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
result=M*v
result=list(result)
return result
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0824, 2022-04-28 08:15:36, xPx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
check=np.arange(v.shape[0])
check2=check==v
check3=np.sum(check)
if(check3==v.shape[0]) :
return True
return False
for i in range(v.shape[0]):
if v[i] != i: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
x=np.array(v)[::-1]
result=u+x
return result
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
result=M*v
result=list(result)
return result
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0825, 2022-04-28 08:11:20, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x = np.range(v.shape[0]) = v
if np.sum(x) == v.shape[0]:
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
x = u + v[::-1]
return x
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0826, 2022-04-28 08:11:35, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x = np.range(v.shape[0]) = v
if np.sum(x) == v.shape[0]:
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
x = u + v[::-1]
return x
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
pass
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0827, 2022-04-28 08:14:29, -Px (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pass
def f2(u, v):
# u and v are 1-D numpy array of equal size
x = u + v[::-1]
return x
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
pass
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0828, 2022-04-28 08:12:43, xx- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return np.sum(np.arange(1,v.shape[0]) & v) == v.shape[0]
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
a = np.arange(1,n)
return np.array(u[::]+v[::-1]) + a
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0829, 2022-04-28 08:14:15, xP- (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return np.sum(np.arange(1,v.shape[0]) & v) == v.shape[0]
def f2(u, v):
# u and v are 1-D numpy array of equal size
return np.array(u[::]+v[::-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0830, 2022-04-28 08:15:46, xP- (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return np.sum(np.arange(1,v.shape[0]) & v) == 0
def f2(u, v):
# u and v are 1-D numpy array of equal size
return np.array(u[::]+v[::-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0831, 2022-04-28 08:13:50, x-P (33%)
import numpy as np
def f1(v):
if v == np.arange(v.shape[0]):
return True
else:
return False
def f2(u, v):
return u + (v-np.arange(u.shape[0])-1)
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.array(M[:, :] * v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0832, 2022-04-28 08:15:39, x-P (33%)
import numpy as np
def f1(v):
z = np.arange(v.shape[0])
if v == z:
return True
else:
return False
def f2(u, v):
return u + (v-np.arange(u.shape[0])-1)
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.array(M[:, :] * v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0833, 2022-04-28 08:17:14, x-P (33%)
import numpy as np
def f1(v):
z = np.arange(v.shape[0])
if v == z:
return True
else:
return False
def f2(u, v):
return u + (v+np.arange(u.shape[0])-1)
def f3(M, v):
return np.array(M[:, :] * v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0834, 2022-04-28 08:05:53, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x = np.arange(v.shape[0])
p = sum(v==x)
if v.shape[0] != p:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0835, 2022-04-28 08:06:34, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x = np.arange(v.shape[0])
p = sum(v==x)
if v.shape[0] != p:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0836, 2022-04-28 08:16:25, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x = np.arange(v.shape[0])
p = sum(v==x)
if v.shape[0] != p:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M * v.reshape(M.shape[1],v.shape[0]//M.shape[1])
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0837, 2022-04-28 08:07:14, xxx (0%)
import numpy as np
def f1(v):
lengthv = len(v)
filter_arr = np.arange(lengthv) #[0 1 2 3 4 5]
summ = np.sum(filter_arr)
summ2 = np.sum(v, axis=1)
if summ != summ2: return False
return True
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0838, 2022-04-28 08:13:49, xxx (0%)
import numpy as np
def f1(v):
lengthv = len(v)
filter_arr = np.arange(lengthv) #[0 1 2 3 4 5]
summ = np.sum(filter_arr)
summ2 = np.sum(v, axis=1)
if summ != summ2: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0] #n=10 #9,8,7,0
checker = [True]*n
dl = [False] * (len(v) - n)
l = checker + dl
check = np.array(l)
mask = v[check]
mask2 = mask1[::-1]
out = u + mask2
return out
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0839, 2022-04-28 08:14:15, Pxx (33%)
import numpy as np
def f1(v):
lengthv = len(v)
filter_arr = np.arange(lengthv) #[0 1 2 3 4 5]
summ = np.sum(filter_arr)
summ2 = np.sum(v)
if summ != summ2: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0] #n=10 #9,8,7,0
checker = [True]*n
dl = [False] * (len(v) - n)
l = checker + dl
check = np.array(l)
mask = v[check]
mask2 = mask1[::-1]
out = u + mask2
return out
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0840, 2022-04-28 08:08:01, -P- (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
'''for i in range(v.shape[0]):
if v[i] != i: return False'''
a=np.arange(v.shape[0])
return v[v==a]
def f2(u, v):
# u and v are 1-D numpy array of equal size
#n = u.shape[0]
a=v[-1::-1]
return u+a
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
'''A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)'''
return np.dot(M,v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0841, 2022-04-28 08:10:22, -P- (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
'''for i in range(v.shape[0]):
if v[i] != i: return False'''
a=np.arange(v.shape[0])
return np.sum(v[v==a])==v.shape[0]
def f2(u, v):
# u and v are 1-D numpy array of equal size
#n = u.shape[0]
a=v[-1::-1]
return u+a
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
'''A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)'''
return np.dot(M,v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0842, 2022-04-28 08:15:10, -P- (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
'''for i in range(v.shape[0]):
if v[i] != i: return False'''
a=np.arange(v.shape[0])
return np.sum(v[v==a])==v.shape[0]
def f2(u, v):
# u and v are 1-D numpy array of equal size
#n = u.shape[0]
a=v[-1::-1]
return u+a
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
'''A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)'''
return np.dot(M,v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0843, 2022-04-28 08:14:04, -Px (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x=np.arange(v.shape[0])
if np.sum(x==v) == 0:
return True
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
i = np.arange(u.shape[0])
return u[i]+v[n-i-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0844, 2022-04-28 08:15:02, -Px (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x=np.arange(v.shape[0])
if np.sum(x==v) == 0:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
i = np.arange(u.shape[0])
return u[i]+v[n-i-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0845, 2022-04-28 08:10:49, --P (33%)
import numpy as np
def f1(v):
r = np.arange(v.shape[0])
check = v[r] != r
tf = np.sum(check)
if tf == 0:
return False
else:
return True
def f2(u, v):
n = u.shape[0]
ran = np.arange(n)
return np.array([u[ran]+v[n-ran-1]])
def f3(M, v):
j = np.arange(M.shape[1])
mul = M[:,j] * v[j]
return np.array(mul)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0846, 2022-04-28 08:15:33, --P (33%)
import numpy as np
def f1(v):
r = np.arange(v.shape[0])
check = v[r] != r
tf = np.sum(check)
if tf == 0:
return False
else:
return True
def f2(u, v):
n = u.shape[0]
ran = np.arange(n)
return np.array([u[ran]+v[n-ran-1]])
def f3(M, v):
j = np.arange(M.shape[1])
mul = M[:,j] * v[j]
return mul.reshape((M.shape[0],M.shape[1]))
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0847, 2022-04-28 08:15:08, -Px (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(v.shape[0])
if np.sum(v[v == pos]) != v.shape[0]: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
x = np.arange(n)
return u[x] + v[n-x-1]
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0848, 2022-04-28 08:16:00, -Px (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(v.shape[0])
if np.sum(v[v != pos]) != v.shape[0]: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
x = np.arange(n)
return u[x] + v[n-x-1]
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0849, 2022-04-28 08:15:23, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
n = v.shape[0]
ch = np.arange(0,n,1)
ans = ch != v
ans1 = sum(ans)
if ans1 != 0:
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
newu = u[:n:]
newv = v[n-1::-1]
return newu+newv
for k in range(int(input())):
exec(input().strip())
| # 0850, 2022-04-28 08:16:05, Px- (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
n = v.shape[0]
ch = np.arange(0,n,1)
ans = ch != v
ans1 = sum(ans)
if ans1 != 0:
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
newu = u[:n:]
newv = v[n-1::-1]
return newu+newv
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
a = []
b = M[:M.shape[0]:,:M.shape[1]:]*v[:M.shape[1]:]
A.append(b)
return np.array(A)
for k in range(int(input())):
exec(input().strip())
|
# 0851, 2022-04-28 08:15:02, P-x (33%)
import numpy as np
def f1(v):
if False not in (v == np.arange(v.shape[0])):
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
v += u
return v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0852, 2022-04-28 08:16:53, P-- (33%)
import numpy as np
import numpy as np
def f1(v):
if False not in (v == np.arange(v.shape[0])):
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
v += u
return v[::-1]
def f3(M, v):
k = M+v
return np.array(k)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0853, 2022-04-28 08:10:10, -xx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if np.sum(v) == (1+(v[-1])*(v[-1]/2)) : return True
else : return False
def f2(u, v):
pass
def f3(M, v):
pass
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0854, 2022-04-28 08:14:05, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if np.sum(v) == np.sum(np.arange(0,v.shape[0])) : return True
else : return False
def f2(u, v):
pass
def f3(M, v):
pass
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0855, 2022-04-28 08:14:25, -xx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
k = np.arange(v.shape[0])
new_v = np.sum(v == k)
newnew = new_v == v.shape[0]
return
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = np.arange(u.shape[0])
return np.array(n[u] + v[u.shape[0]-n-1])
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0856, 2022-04-28 08:15:53, -xP (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
k = np.arange(v.shape[0])
new_v = np.sum(v == k)
newnew = new_v == v.shape[0]
return
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = np.arange(u.shape[0])
return np.array(n[u] + v[u.shape[0]-n-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M * v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0857, 2022-04-28 08:12:48, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
for i in range(v.shape[0]):
if v[i] != i: return False
return True
for k in range(int(input())):
exec(input().strip())
| # 0858, 2022-04-28 08:13:14, Pxx (33%)
import numpy as np
def f1(v):
a = np.arange(v.shape[0])
b = a==v
if False in b:
return False
return True
for k in range(int(input())):
exec(input().strip())
|
# 0859, 2022-04-28 08:16:29, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
'''
for i in range(v.shape[0]):
if v[i] != i: return False
return True
'''
ind = np.arange(v.shape[0])
check = v==ind
if False in check:
return False
else : return True
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0860, 2022-04-28 08:16:40, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
'''
for i in range(v.shape[0]):
if v[i] != i: return False
return True
'''
ind = np.arange(v.shape[0])
check = v==ind
if False in check:
return False
else : return True
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0861, 2022-04-28 08:10:43, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
ar_v = np.array(v)
range_v = np.arange(0,len(ar_v))
if sum(ar_v == range_v) == len(ar_v) :
return True
else :
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0862, 2022-04-28 08:11:25, Pxx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
ar_v = np.array(v)
range_v = np.arange(0,len(ar_v))
if sum(ar_v == range_v) == len(ar_v) :
return True
else :
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
pass
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
pass
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0863, 2022-04-28 08:15:53, compilation error (0%)
import numpy as np
def f1(v):
A = np.arange(len(v))
if np.sum(A==v) !=len(v) :
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0864, 2022-04-28 08:16:37, Pxx (33%)
import numpy as np
def f1(v):
A = np.arange(len(v))
if np.sum(A==v) !=len(v) :
return False
else:
return True
def f2(u, v):
return 0
def f3(M, v):
return 0
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0865, 2022-04-28 08:13:39, xPx (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
for i in range(v.shape[0]):
if v[i] != i: return False
return True
def f2(u, v):
return u+v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0866, 2022-04-28 08:15:48, xP- (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
for i in range(v.shape[0]):
if v[i] != i: return False
return True
def f2(u, v):
return u+v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M.dot(v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0867, 2022-04-28 08:13:12, -Px (33%)
import numpy as np
def f1(v):
a = (v != np.arange(v.shape[0]))
if sum(a) != 0:
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
i = np.arange(n)
a = u[i] + v[n-i-1]
return a
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0868, 2022-04-28 08:15:35, -P- (33%)
import numpy as np
def f1(v):
a = (v != np.arange(v.shape[0]))
if sum(a) != 0:
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
i = np.arange(n)
a = u[i] + v[n-i-1]
return a
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.dot(M,v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0869, 2022-04-28 08:15:44, -P- (33%)
import numpy as np
def f1(v):
# v: 1-D numpy array
range = np.arange(v.shape[0])
if np.sum(v[v == range]) < v.shape[0]:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return np.array(u + v[::-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M.dot(v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0870, 2022-04-28 08:16:58, xPx (33%)
import numpy as np
def f1(v):
v = v==i
if np.min(v)==0:
return 0
else:
return 1
def f2(u, v):
r = u[::]+v[::-1]
return r
for k in range(int(input())):
exec(input().strip())
|
# 0871, 2022-04-28 08:14:17, P-- (33%)
from turtle import shape
import numpy as np
def f1(v):
# v: 1-D numpy array
mul= np.arange(v.shape[0])
charray = np.array(v == mul)
if(np.sum(charray)==v.shape[0]):return True
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[:]+v[::-1]])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0872, 2022-04-28 08:03:16, xxx (0%)
import numpy as np
def f1(v):
for i in range(v.shape[0]):
if v[i] != i: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0873, 2022-04-28 08:04:03, xxx (0%)
import numpy as np
def f1(v):
v = np.array(v)
for i in range(v.shape[0]):
if v[i] != i: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0874, 2022-04-28 08:05:52, xxx (0%)
import numpy as np
def f1(v):
v = v.T
for i in range(v.shape[0]):
if v[i] != i: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0875, 2022-04-28 08:10:35, -xx (0%)
import numpy as np
def f1(v):
v = v.T
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0876, 2022-04-28 08:10:45, -xx (0%)
import numpy as np
def f1(v):
v = v.T
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0877, 2022-04-28 08:12:32, -xx (0%)
import numpy as np
def f1(v):
return v.T
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0878, 2022-04-28 08:12:51, -x- (0%)
import numpy as np
def f1(v):
return v.T
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0879, 2022-04-28 08:13:18, --- (0%)
import numpy as np
def f1(v):
return v.T
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array(u)
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0880, 2022-04-28 08:13:56, --- (0%)
import numpy as np
def f1(v):
return np.array(v)
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array(u)
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0881, 2022-04-28 08:14:13, --- (0%)
import numpy as np
def f1(v):
return np.array(v)
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array(u)
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0882, 2022-04-28 08:15:04, --- (0%)
import numpy as np
def f1(v):
return v[0]
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array(u)
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0883, 2022-04-28 08:15:10, --- (0%)
import numpy as np
def f1(v):
return v[0]
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array(u)
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0884, 2022-04-28 08:15:31, --- (0%)
import numpy as np
def f1(v):
return v[0]
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array(u)
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0885, 2022-04-28 08:15:46, --- (0%)
import numpy as np
def f1(v):
return v[0]
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array(u)
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0886, 2022-04-28 08:05:28, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x = v[::1,0]
if x != v.shape[0]:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0887, 2022-04-28 08:06:34, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x = v[::1]
if x != v.shape[0]:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0888, 2022-04-28 08:14:04, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
ans = np.arange(,v.shape[0])
return np.sum(v == ans) == v.shape[0]
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
vnew =np.array(v)
return M * vnew
exec(input().strip())
| # 0889, 2022-04-28 08:14:14, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
ans = np.arange(,v.shape[0])
return np.sum(v == ans) == v.shape[0]
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
vnew =np.array(v)
return M * vnew
exec(input().strip())
| # 0890, 2022-04-28 08:14:48, compilation error (0%) import numpy as np def f1(v): # v: 1-D numpy array ans = np.arange(,v.shape[0]) return np.sum(v == ans) == v.shape[0] def f2(u, v): # u and v are 1-D numpy array of equal size return u + v[::-1] def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] vnew =np.array(v) return M * vnew exec(input().strip()) | # 0891, 2022-04-28 08:15:51, compilation error (0%) import numpy as np def f1(v): # v: 1-D numpy array ans = np.arange(,v.shape[0]) return np.sum(v == ans) == v.shape[0] def f2(u, v): # u and v are 1-D numpy array of equal size return u + v[::-1] def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] vnew =np.array(v) return M * vnew #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0892, 2022-04-28 08:15:56, compilation error (0%) import numpy as np def f1(v): # v: 1-D numpy array ans = np.arange(,v.shape[0]) return np.sum(v == ans) == v.shape[0] def f2(u, v): # u and v are 1-D numpy array of equal size return u + v[::-1] def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] vnew =np.array(v) return M * vnew #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0893, 2022-04-28 08:16:32, compilation error (0%) import numpy as np def f1(v): ans = np.arange(,v.shape[0]) return np.sum(v == ans) == v.shape[0] def f2(u, v): return u + v[::-1] def f3(M, v): vnew =np.array(v) return M * vnew for k in range(int(input())): exec(input().strip()) | # 0894, 2022-04-28 08:17:09, compilation error (0%) import numpy as np def f1(v): ans = np.arange(,v.shape[0]) return np.sum(v == ans) == v.shape[0] def f2(u, v): return u + v[::-1] def f3(M, v): vnew =np.array(v) return M * vnew for k in range(int(input())): exec(input().strip()) |
# 0895, 2022-04-28 08:10:24, --- (0%)
from cmath import e
import numpy as np
def f1(v):
# v: 1-D numpy array
if v != np.arange(0,v.shape[0]):
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array()
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
exec(input().strip())
| # 0896, 2022-04-28 08:12:00, --- (0%)
from cmath import e
import numpy as np
def f1(v):
# v: 1-D numpy array
if v != np.arange(0,v.shape[1]):
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u+v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
exec(input().strip())
| # 0897, 2022-04-28 08:12:13, --- (0%)
from cmath import e
import numpy as np
def f1(v):
# v: 1-D numpy array
if v != np.arange(0,v.shape[1]):
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u+v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
exec(input().strip())
| # 0898, 2022-04-28 08:12:58, --- (0%)
from cmath import e
import numpy as np
def f1(v):
# v: 1-D numpy array
if v != np.arange(0,v.shape[1]):
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u+v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
exec(input().strip())
| # 0899, 2022-04-28 08:13:21, --- (0%)
from cmath import e
import numpy as np
def f1(v):
# v: 1-D numpy array
if v != np.arange(0,v.shape[1]):
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u+v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
exec(input().strip())
| # 0900, 2022-04-28 08:15:01, compilation error (0%)
from cmath import e
import numpy as np
def f1(v):
# v: 1-D numpy array
if v != np.arange(0,v.shape[1]):
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u+v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
exec(input().strip())
| # 0901, 2022-04-28 08:15:32, compilation error (0%)
from cmath import e
import numpy as np
def f1(v):
# v: 1-D numpy array
if v != np.arange(0,v.shape[1]):
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u+v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
exec(input().strip())
| # 0902, 2022-04-28 08:16:16, --- (0%)
from cmath import e
import numpy as np
def f1(v):
# v: 1-D numpy array
if v != np.arange(0,v.shape[1]):
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u+v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return
exec(input().strip())
|
# 0903, 2022-04-28 08:05:49, compilation error (0%) import numpy as np def f1(v): i = np.arange(len(v)) return v = i | # 0904, 2022-04-28 08:06:01, --- (0%) import numpy as np def f1(v): i = np.arange(len(v)) return v == i | # 0905, 2022-04-28 08:07:52, --- (0%) import numpy as np def f1(v): i = np.arange(v.shape[0]) return v == i | # 0906, 2022-04-28 08:09:47, --- (0%) import numpy as np def f1(v): i = np.arange(v.shape[0]) return v == i def f2(u, v): n = u.shape[0] return np.array([u+v[n-1::-1,]]) | # 0907, 2022-04-28 08:15:42, compilation error (0%)
import numpy as np
def f1(v):
i = np.arange(v.shape[0])
a = np.sum(v != i)
if a != v.shape[0]:
return False
return True
def f2(u, v):
n = u.shape[0]
return np.array([u+v[n-1::-1,]])
| # 0908, 2022-04-28 08:16:07, compilation error (0%)
import numpy as np
def f1(v):
i = np.arange(v.shape[0])
a = np.sum(v != i)
if a != v.shape[0]:
return False
return True
def f2(u, v):
n = u.shape[0]
return np.array([u+v[n-1::-1,]])
def f3(M, v):
return v*M
| # 0909, 2022-04-28 08:16:39, --- (0%) import numpy as np def f1(v): return True def f2(u, v): n = u.shape[0] return np.array([u+v[n-1::-1,]]) def f3(M, v): return v*M | # 0910, 2022-04-28 08:17:08, --- (0%) import numpy as np def f1(v): return True def f2(u, v): n = u.shape[0] return np.array([u+v[n-1::-1,]]) def f3(M, v): return v*M |
# 0911, 2022-04-28 08:01:52, compilation error (0%) import numpy as np def f1(v): # v: 1-D numpy array for i in range(v.shape[0]): if v[i] != i: return False return True def f2(u, v): # u and v are 1-D numpy array of equal size n = u.shape[0] return np.array([u[i]+v[n-i-1] for i in range(n)]) def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] A = [] for i in range(M.shape[0]): a = [] for j in range(M.shape[1]): a.append(M[i,j] * v[j]) A.append(a) return np.array(A) #----- DON'T modify any of the following lines ----- for k in range(int(input())) | # 0912, 2022-04-28 08:06:33, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
for i in range(v.shape[0]):
if v[i] != i: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0913, 2022-04-28 08:10:19, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
def f1(v):
x1 = np.array([10]*v.shape[0]) ** np.arange(v.shape[0])
if np.sum(v*x1) == np.sum(np.arange(v.shape[0])*x1):
return True
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
pass
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
pass
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0914, 2022-04-28 08:13:50, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
def f1(v):
power = np.array([10]*v.shape[0]) ** np.arange(v.shape[0])
if np.sum(v*power) == np.sum(np.arange(v.shape[0])*power): return True
return False
def f2(u,v):
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
pass
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0915, 2022-04-28 08:14:56, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
def f1(v):
x = np.array([10]*x.shape[0]) ** np.arange(v.shape[0])
if np.sum(v*x) == np.sum(np.arange(v.shape[0])*x): return True
return False
def f2(u,v):
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0916, 2022-04-28 08:15:30, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
def f1(v):
x = np.array([10]*x.shape[0]) ** np.arange(v.shape[0])
if np.sum(v*x) == np.sum(np.arange(v.shape[0])*x): return True
return False
def f2(u,v):
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0917, 2022-04-28 08:16:14, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
def f1(v):
x = np.array([10]*x.shape[0]) ** np.arange(v.shape[0])
if np.sum(v*x) == np.sum(np.arange(v.shape[0])*x): return True
return False
def f2(u,v):
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0918, 2022-04-28 08:17:01, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
def f1(v):
x = np.array([10]*x.shape[0]) ** np.arange(v.shape[0])
if np.sum(v*x) == np.sum(np.arange(v.shape[0])*x): return True
return False
def f2(u,v):
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0919, 2022-04-28 08:03:14, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
for i in range(v.shape[0]):
if v[i] != i: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0920, 2022-04-28 08:06:46, -xx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x=np.arange(0,v.shape[0],1)
return
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0921, 2022-04-28 08:07:45, -xx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x=np.arange(0,v.shape[0],1)
return v[v!=x]
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0922, 2022-04-28 08:11:59, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x=np.arange(v.shape[0])
y=v!=x
z=np.sum(y)
return z
def f2(u, v):
# u and v are 1-D numpy array of equal size
x=v[::-1]
return np.array(u+x)
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
x=M*v
return x
| # 0923, 2022-04-28 08:13:11, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x=np.arange(v.shape[0])
y=v!=x
z=np.sum(y)
return z==0
def f2(u, v):
# u and v are 1-D numpy array of equal size
x=v[::-1]
return np.array(u+x)
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
x=M*v
return x
| # 0924, 2022-04-28 08:14:13, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x=np.arange(v.shape[0])
y=v!=x
z=np.sum(y)
return z==0
def f2(u, v):
# u and v are 1-D numpy array of equal size
x=v[::-1]
return np.array(u+x)
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
| # 0925, 2022-04-28 08:14:58, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x=np.arange(v.shape[0])
y=v!=x
z=np.sum(y)
return z==0
def f2(u, v):
# u and v are 1-D numpy array of equal size
x=u[:] + v[u.shape[0]::-1]
return x
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
|
# 0926, 2022-04-28 08:05:43, compilation error (0%) import numpy as np def f1(v): # v: 1-D numpy array i = np.arange(v.shape[0]): if v[i] != i: return False return True def f2(u, v): # u and v are 1-D numpy array of equal size n = u.shape[0] return np.array([u[i]+v[n-i-1] i = np.arange(v.shape[0])]) def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] A = [] i = np.arange(M.shape[0]): a = [] j = np.arange(M.shape[1]): a.append(M[i,j] * v[j]) A.append(a) return np.array(A) #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0927, 2022-04-28 08:06:14, compilation error (0%) import numpy as np def f1(v): # v: 1-D numpy array i = np.arange(v.shape[0]): if v[i] != i: return False return True def f2(u, v): # u and v are 1-D numpy array of equal size n = u.shape[0] return np.array([u[i]+v[n-i-1] i = np.arange(v.shape[0])]) def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] A = [] i = np.arange(M.shape[0]): a = [] j = np.arange(M.shape[1]): a.append(M[i,j] * v[j]) A.append(a) return np.array(A) #----- DON'T modify any of the following lines ----- exec(input().strip()) | # 0928, 2022-04-28 08:08:40, compilation error (0%) import numpy as np def f1(v): # v: 1-D numpy array i = np.arange(v.shape[0]): if v[::-1] != i: return False return True def f2(u, v): # u and v are 1-D numpy array of equal size n = u.shape[0] return np.array([i = np.arange(v.shape[0]) and u[i]+v[n-i-1] ]) def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] A = [] i = np.arange(M.shape[0]): a = [] j = np.arange(M.shape[1]): a.append(M[i,j] * v[j]) A.append(a) return np.array(A) #----- DON'T modify any of the following lines ----- exec(input().strip()) | # 0929, 2022-04-28 08:11:46, compilation error (0%) import numpy as np def f1(v): # v: 1-D numpy array i = np.arange(v.shape[0]) if v[::-1] != i: return False return True def f2(u, v): # u and v are 1-D numpy array of equal size n = u.shape[0] return np.array([i = np.arange(v.shape[0]) and u[i]+v[n-i-1] ]) def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] A = [] i = np.arange(M.shape[0]): a = [] j = np.arange(M.shape[1]): a.append(M[i,j] * v[j]) A.append(a) return np.array(A) #----- DON'T modify any of the following lines ----- exec(input().strip()) | # 0930, 2022-04-28 08:12:17, compilation error (0%) import numpy as np def f1(v): # v: 1-D numpy array i = np.arange(v.shape[0]) if v[::-1] != i: return False return True def f2(u, v): # u and v are 1-D numpy array of equal size n = u.shape[0] return np.array([i = np.arange(v.shape[0]) and u[i]+v[n-i-1] ]) def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] A = [] i = np.arange(M.shape[0]) a = [] j = np.arange(M.shape[1]) a.append(M[i,j] * v[j]) A.append(a) return np.array(A) #----- DON'T modify any of the following lines ----- exec(input().strip()) | # 0931, 2022-04-28 08:12:47, compilation error (0%) import numpy as np def f1(v): # v: 1-D numpy array i = np.arange(v.shape[0]) if v[::-1] != i: return False return True def f2(u, v): # u and v are 1-D numpy array of equal size n = u.shape[0] return np.array([i = np.arange(v.shape[0]) and u[i]+v[n-i-1] ]) def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] A = [] i = np.arange(M.shape[0]) a = [] j = np.arange(M.shape[1]) a.append(M[i,j] * v[j]) A.append(a) return np.array(A) #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0932, 2022-04-28 08:13:52, compilation error (0%) import numpy as np def f1(v): # v: 1-D numpy array i = np.arange(v.shape[0]) if v[i] != i: return False return True def f2(u, v): # u and v are 1-D numpy array of equal size n = u.shape[0] return np.array([i = np.arange(v.shape[0]) and u[i]+v[n-i-1] ]) def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] A = [] i = np.arange(M.shape[0]) a = [] j = np.arange(M.shape[1]) a.append(M[i,j] * v[j]) A.append(a) return np.array(A) #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) |
# 0933, 2022-04-28 08:03:42, -xx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return v[:] == np.arange(v.shape[0])
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0934, 2022-04-28 08:04:39, -xx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return v == np.arange(v.shape[0])
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0935, 2022-04-28 08:09:57, x-x (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return v == np.arange([v.shape[0]])
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array(u[:] + v[-1:])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0936, 2022-04-28 08:12:11, x-- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return v == np.arange([v.shape[0]])
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array(u[:] + v[-1:])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M.dot(v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0937, 2022-04-28 08:15:20, x-- (0%)
import numpy as np
def f1(v):
return v == np.arange([v.shape[0]])
def f2(u, v):
n = u.shape[0]
return np.array(u[:] + v[-1:])
def f3(M, v):
return M.dot(v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0938, 2022-04-28 08:17:07, x-- (0%)
import numpy as np
def f1(v):
return v == np.arange([v.shape[0]])
def f2(u, v):
return np.array(u[:] + v[-1:])
def f3(M, v):
return M.dot(v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0939, 2022-04-28 08:09:59, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a=np.array(v)
b=a[a !=a]
return True
#for i in range(v.shape[0]):
# if v[i] != i: return False
#return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
pass
#n = u.shape[0]
#return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
pass
#A = []
#for i in range(M.shape[0]):
# a = []
# for j in range(M.shape[1]):
# a.append(M[i,j] * v[j])
A.append(a)
#return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0940, 2022-04-28 08:13:35, compilation error (0%) import numpy as np def f1(v): # v: 1-D numpy array a=np.array(v) b=a[a !=a] return True #for i in range(v.shape[0]): # if v[i] != i: return False #return True def f2(u, v): # u and v are 1-D numpy array of equal size pass #n = u.shape[0] #return np.array([u[i]+v[n-i-1] for i in range(n)]) def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] n=len(M) a=np.dot(M,v) return a #A = [] #for i in range(M.shape[0]): # a = [] # for j in range(M.shape[1]): # a.append(M[i,j] * v[j]) # A.append(a) #return np.array(A) #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0941, 2022-04-28 08:13:42, -x- (0%) import numpy as np def f1(v): # v: 1-D numpy array a=np.array(v) b=a[a !=a] return True #for i in range(v.shape[0]): # if v[i] != i: return False #return True def f2(u, v): # u and v are 1-D numpy array of equal size pass #n = u.shape[0] #return np.array([u[i]+v[n-i-1] for i in range(n)]) def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] n=len(M) a=np.dot(M,v) return a #A = [] #for i in range(M.shape[0]): # a = [] # for j in range(M.shape[1]): # a.append(M[i,j] * v[j]) # A.append(a) #return np.array(A) #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0942, 2022-04-28 08:13:53, -x- (0%) import numpy as np def f1(v): # v: 1-D numpy array a=np.array(v) b=a[a !=a] return True #for i in range(v.shape[0]): # if v[i] != i: return False #return True def f2(u, v): # u and v are 1-D numpy array of equal size pass #n = u.shape[0] #return np.array([u[i]+v[n-i-1] for i in range(n)]) def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] n=len(M) a=np.dot(M,v) return a #A = [] #for i in range(M.shape[0]): # a = [] # for j in range(M.shape[1]): # a.append(M[i,j] * v[j]) # A.append(a) #return np.array(A) #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0943, 2022-04-28 08:15:57, -x- (0%) import numpy as np def f1(v): # v: 1-D numpy array a=np.array(v) b=a[a !=a] return True #for i in range(v.shape[0]): # if v[i] != i: return False #return True def f2(u, v): # u and v are 1-D numpy array of equal size pass #n = u.shape[0] #return np.array([u[i]+v[n-i-1] for i in range(n)]) def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] n=len(M) a=np.dot(M[0],v) b=np.dot(M[1],v) return a #A = [] #for i in range(M.shape[0]): # a = [] # for j in range(M.shape[1]): # a.append(M[i,j] * v[j]) # A.append(a) #return np.array(A) #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0944, 2022-04-28 08:16:58, -xx (0%) import numpy as np def f1(v): # v: 1-D numpy array a=np.array(v) b=a[a !=a] return True #for i in range(v.shape[0]): # if v[i] != i: return False #return True def f2(u, v): # u and v are 1-D numpy array of equal size pass #n = u.shape[0] #return np.array([u[i]+v[n-i-1] for i in range(n)]) def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] n=len(M) a=np.dot(M[0],v) b=np.dot(M[1],v) a=list(a) b=list(b) c=a+b c=np.array(c) return c #A = [] #for i in range(M.shape[0]): # a = [] # for j in range(M.shape[1]): # a.append(M[i,j] * v[j]) # A.append(a) #return np.array(A) #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) |
# 0945, 2022-04-28 08:08:51, --- (0%)
import numpy as np
def f1(v):
r = v.shape[0]
v = a != r
b = np.sum(v)
if b != r:
return False
else:
return True
| # 0946, 2022-04-28 08:11:14, --- (0%)
import numpy as np
def f1(v):
r = v.shape[0]
l = len(v)
v = a != r
b = np.sum(v)
if b != l:
return False
else:
return True
| # 0947, 2022-04-28 08:12:48, --- (0%)
import numpy as np
def f1(v):
x = np.arange(v.shape[0])
if v != x :
return False
return True
| # 0948, 2022-04-28 08:13:59, xxx (0%)
import numpy as np
def f1(v):
r = v.shape[0]
v = a != r
l = len(v)
b = np.sum(v)
if b != l:
return False
else:
return True
for k in range(int(input())):
exec(input().strip())
| # 0949, 2022-04-28 08:14:34, xxx (0%)
import numpy as np
def f1(v):
x = np.arange(v.shape[0])
if v != x :
return False
return True
for k in range(int(input())):
exec(input().strip())
| # 0950, 2022-04-28 08:15:36, xxx (0%)
import numpy as np
def f1(v):
r = v.shape[0]
v = a != r
l = len(v)
b = np.sum(v)
if b != l:
return False
else:
return True
for k in range(int(input())):
exec(input().strip())
|
# 0951, 2022-04-28 08:13:18, --- (0%)
import numpy as np
def f1(v):
indexx = np.arange(0,v.shape[0],1)
k = v[v==indexx]
return k
# v: 1-D numpy array
'''for i in range(v.shape[0]):
if v[i] != i: return False
return True'''
def f2(u, v):
return u[:,:] + v[u.shape[0]-1::,:]
# u and v are 1-D numpy array of equal size
'''n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])'''
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array
| # 0952, 2022-04-28 08:14:21, --- (0%)
import numpy as np
def f1(v):
indexx = np.arange(0,v.shape[0],1)
k = v[v==indexx]
return k
# v: 1-D numpy array
'''for i in range(v.shape[0]):
if v[i] != i: return False
return True'''
def f2(u, v):
return u + v[::-1]
# u and v are 1-D numpy array of equal size
'''n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])'''
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array
| # 0953, 2022-04-28 08:14:53, --- (0%)
import numpy as np
def f1(v):
indexx = np.arange(0,v.shape[0],1)
k = v[v==indexx]
return k
# v: 1-D numpy array
'''for i in range(v.shape[0]):
if v[i] != i: return False
return True'''
def f2(u, v):
return u + v[::-1]
# u and v are 1-D numpy array of equal size
'''n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])'''
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
| # 0954, 2022-04-28 08:15:13, --- (0%)
import numpy as np
def f1(v):
indexx = np.arange(0,v.shape[0],1)
k = v[v==indexx]
return k[0,0]
# v: 1-D numpy array
'''for i in range(v.shape[0]):
if v[i] != i: return False
return True'''
def f2(u, v):
return u + v[::-1]
# u and v are 1-D numpy array of equal size
'''n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])'''
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
| # 0955, 2022-04-28 08:16:23, compilation error (0%)
import numpy as np
def f1(v):
indexx = np.arange(0,v.shape[0],1)
k = v[v==indexx]
return k[0,0]
# v: 1-D numpy array
'''for i in range(v.shape[0]):
if v[i] != i: return False
return True'''
def f2(u, v):
return u + v[::-1]
# u and v are 1-D numpy array of equal size
'''n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])'''
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
exec(input().strip()
| # 0956, 2022-04-28 08:16:43, --- (0%)
import numpy as np
def f1(v):
indexx = np.arange(0,v.shape[0],1)
k = v[v==indexx]
return k[0,0]
# v: 1-D numpy array
'''for i in range(v.shape[0]):
if v[i] != i: return False
return True'''
def f2(u, v):
return u + v[::-1]
# u and v are 1-D numpy array of equal size
'''n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])'''
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
exec(input().strip())
|
# 0957, 2022-04-28 08:03:54, --- (0%)
import numpy as np
def f1(v):
check = np.arange(0,v.shape[0])
if v == check:
return True
return False
| # 0958, 2022-04-28 08:07:53, --- (0%)
import numpy as np
def f1(v):
check = np.arange(0,v.shape[0])
if v & check:
return True
return False
| # 0959, 2022-04-28 08:12:44, compilation error (0%)
import numpy as np
def f1(v):
check = np.arange(0,v.shape[0])
if v & check:
return True
return False
# v: 1-D numpy array
#for i in range(v.shape[0]):
# if v[i] != i: return False
#return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
v = np.concatenate((v[-1:], v[:-1]))
return u + v
#n = u.shape[0]
#return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
#A = []
#for i in range(M.shape[0]):
# a = []
# for j in range(M.shape[1]):
# a.append(M[i,j] * v[j])
# A.append(a)
#return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0960, 2022-04-28 08:13:33, compilation error (0%)
import numpy as np
def f1(v):
check = np.arange(0,v.shape[0])
if v == check:
return True
return False
# v: 1-D numpy array
#for i in range(v.shape[0]):
# if v[i] != i: return False
#return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
v = np.concatenate((v[-1:], v[:-1]))
return u + v
#n = u.shape[0]
#return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
#A = []
#for i in range(M.shape[0]):
# a = []
# for j in range(M.shape[1]):
# a.append(M[i,j] * v[j])
# A.append(a)
#return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0961, 2022-04-28 08:15:05, x-x (0%)
import numpy as np
def f1(v):
check = np.arange(0,v.shape[0])
if v == check:
return True
return False
# v: 1-D numpy array
#for i in range(v.shape[0]):
# if v[i] != i: return False
#return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
v = np.concatenate((v[-1:], v[:-1]))
return u + v
#n = u.shape[0]
#return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
#A = []
#for i in range(M.shape[0]):
# a = []
# for j in range(M.shape[1]):
# a.append(M[i,j] * v[j])
# A.append(a)
#return np.array(A)
return
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0962, 2022-04-28 08:02:21, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
k = v.shape[0]
if v[:k] != k :
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0963, 2022-04-28 08:04:57, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
k = v.shape[0]
if v[k] != k :
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0964, 2022-04-28 08:09:48, xxx (0%)
def f1(v):
# v: 1-D numpy array
k = v.shape[0]
if v[k] != k :
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
x = u[:,:]
y = v[n-1-x]
z = np.array(x+y)
#np.array([u[i]+v[n-i-1] for i in range(n)])
return z
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0965, 2022-04-28 08:10:41, xx- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
k = v.shape[0]
if v[k] != k :
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
x = u[:,:]
y = v[n-1-x]
z = np.array(x+y)
#np.array([u[i]+v[n-i-1] for i in range(n)])
return z
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
#for i in range(M.shape[0]):
# a = []
# for j in range(M.shape[1]):
##A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0966, 2022-04-28 08:13:48, xx- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
k = v.shape[0]
if v[:k] != v[:k] :
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
x = u[:,:]
y = v[n-1-x]
z = np.array(x+y)
#np.array([u[i]+v[n-i-1] for i in range(n)])
return z
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
x = v.shape[0]
#for i in range(M.shape[0]):
# a = []
# for j in range(M.shape[1]):
##A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0967, 2022-04-28 08:06:56, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
n = v.shape[0]
if v[:n+1] != i: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u[i]+v[n-i-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0968, 2022-04-28 08:07:16, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
n = v.shape[0]
if v[:n+1] != n: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u[n]+v[n-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0969, 2022-04-28 08:10:51, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
n = v.shape[0]
n1 = np.arange(1,n+1)
if n1 != n: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u[n]+v[n-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0970, 2022-04-28 08:12:09, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
n = v.shape[0]
n1 = np.arange(0,n)
if n1 != n: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u[n]+v[n-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0971, 2022-04-28 08:15:28, x-x (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
n = v.shape[0]
n1 = np.arange(0,n)
if n1 != n: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u[::n+1]+v[::n+1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0972, 2022-04-28 08:06:18, compilation error (0%)
def f1(v):
# v: 1-D numpy array
p = np.arange.(v.shape[0])
pos = p == v
npos = pos ==False
if np.sum(npos) == 0:
return False
return True
for k in range(int(input())):
exec(input().strip())
| # 0973, 2022-04-28 08:07:58, compilation error (0%)
def f1(v):
# v: 1-D numpy array
p = np.arange.(v.shape[0])
pos = p == v
npos = pos ==False
if np.sum(npos) != v.shape[0]::
return False
return True
for k in range(int(input())):
exec(input().strip())
| # 0974, 2022-04-28 08:14:37, compilation error (0%)
def f1(v):
# v: 1-D numpy array
p = np.arange.(v.shape[0])
pos = p == v
return np.sum(pos) == v.shape[0]
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return v[::-1] + u
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M * v
for k in range(int(input())):
exec(input().strip())
| # 0975, 2022-04-28 08:15:16, compilation error (0%)
def f1(v):
# v: 1-D numpy array
p = np.arange.(v.shape[0])
pos = p == v
return np.sum(pos) == v.shape[0]
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return v[::-1] + u
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M * v
for k in range(int(input())):
exec(input().strip())
| # 0976, 2022-04-28 08:16:12, compilation error (0%)
def f1(v):
# v: 1-D numpy array
p = np.arange.(v.shape[0])
pos = p == v
return np.sum(pos) == v.shape[0]
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return v[::-1] + u
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M * v
for k in range(int(input())):
exec(input().strip())
|
# 0977, 2022-04-28 08:09:24, compilation error (0%) import numpy as np def f1(v): # v: 1-D numpy array b=np.arange(0,len(v)) f=v!=b return f def f2(u, v): # u and v are 1-D numpy array of equal size n = u.shape[0] return np.array([u[i]+v[n-i-1] for i in range(n)]) def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] A = [] for i in range(M.shape[0]): a = [] for j in range(M.shape[1]): a.append(M[i,j] * v[j]) A.append(a) return np.array(A) #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0978, 2022-04-28 08:10:18, -xx (0%) import numpy as np def f1(v): # v: 1-D numpy array b=np.arange(0,len(v)) f=v!=b return f def f2(u, v): # u and v are 1-D numpy array of equal size n = u.shape[0] return np.array([u[i]+v[n-i-1] for i in range(n)]) def f3(M, v): return 1 #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0979, 2022-04-28 08:10:36, -xx (0%) import numpy as np def f1(v): # v: 1-D numpy array b=np.arange(0,len(v)) f=v!=b return f def f2(u, v): # u and v are 1-D numpy array of equal size n = u.shape[0] return np.array([u[i]+v[n-i-1] for i in range(n)]) def f3(M, v): return 1 #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0980, 2022-04-28 08:12:08, -xx (0%) import numpy as np def f1(v): # v: 1-D numpy array b=np.arange(0,len(v)) f=v!=b return f def f2(u, v): pass def f3(M, v): pass #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 0981, 2022-04-28 08:13:31, -xx (0%) import numpy as np def f1(v): # v: 1-D numpy array b=np.arange(0,len(v)) f=v==b return f def f2(u, v): pass def f3(M, v): pass #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) |
# 0982, 2022-04-28 08:12:39, --- (0%)
def f1(v):
i = np.arange(v.shape[0])
if np.sum(v != 0) != 0: return False
else: return True
def f2(u, v):
return u + v[::-1]
def f3(M, v):
return M*v
| # 0983, 2022-04-28 08:12:47, --- (0%)
def f1(v):
i = np.arange(v.shape[0])
if np.sum(v != 0) != 0: return False
else: return True
def f2(u, v):
return u + v[::-1]
| # 0984, 2022-04-28 08:14:58, --- (0%)
def f1(v):
i = np.arange(v.shape[0])
if np.sum(v != 0) != 0: return False
else: return True
def f2(u, v):
return u + v[::-1]
def f3(M, v):
return M*v
| # 0985, 2022-04-28 08:15:10, --- (0%)
def f1(v):
i = np.arange(v.shape[0])
if np.sum(v != 0) != 0: return False
else: return True
def f2(u, v):
return u + v[::-1]
def f3(M, v):
return M*v
| # 0986, 2022-04-28 08:15:35, --- (0%)
def f1(v):
i = np.arange(v.shape[0])
if np.sum(v != 0) != 0: return False
else: return True
def f2(u, v):
return u + v[::-1]
def f3(M, v):
return M*v
|
# 0987, 2022-04-28 08:07:33, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
A = np.arrange(v.shape[0])
if v[:v.shape[0]] != A:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
A = u[:n]+v[n-i-1:n]
return A
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0988, 2022-04-28 08:10:23, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
A = np.arrange(v.shape[0])
if v[:v.shape[0]] != A:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
A = u[:n]+v[n-i-1:n]
return A
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
out = M[:M.shape[0],:M.shape[1]] * v[:M.shape[1]]
A.append(out)
return np.array(A)
| # 0989, 2022-04-28 08:14:11, xx- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
A = np.arange(v.shape[0])
if v != A:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
A = u[:n]+v[n-i-1:n]
return A
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
out = M[:M.shape[0],:M.shape[1]] * v[:M.shape[1]]
A.append(out)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0990, 2022-04-28 08:14:47, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
A = np.arange(v.shape[0])
if v[:v.shape[0]] != A:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
A = u[:n]+v[n-i-1:n]
return A
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
out = M[:M.shape[0],:M.shape[1]] * v[:M.shape[1]]
A.append(out)
return np.array(A)
v = np.array([0,1,2,3,4])
print(f1(v))
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0991, 2022-04-28 08:17:14, xx- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
A = np.arange(v.shape[0])
if v[:v.shape[0]] != A:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
A = u[:n]+v[n-i-1:n]
return A
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
out = M[:M.shape[0],:M.shape[1]] * v[:M.shape[1]]
A.append(out)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0992, 2022-04-28 08:07:03, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
plus = np.sum(v,0)
co = v.shape[1]
ch = plus != np.arraange(0,co,1)
if ch == 1:
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0993, 2022-04-28 08:13:03, x-x (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
co = v.shape[1]
ch = v != np.arraange(0,co,1)
if ch[::] :
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
v2 = v.T
x = u+v
return x
#return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0994, 2022-04-28 08:14:02, x-x (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
co = v.shape[1]
ch = v != np.arraange(0,co,1)
if ch[::] :
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
v2 = (v.T).T
x = u+v
return x
#return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0995, 2022-04-28 08:15:52, x-x (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
co = v.shape[1]
r = np.arraange(0,co,1)
ch = v != np.arraange(0,co,1)
if v != r :
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
v2 = (v.T).T
x = u+v
return x
#return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 0996, 2022-04-28 08:16:58, x-x (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
co = v.shape[1]
r = np.arraange(0,co,1)
ch = v != np.arraange(0,co,1)
if v != r :
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
v2 = v[::-1]
x = u+v
return x
#return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 0997, 2022-04-28 08:12:42, xx- (0%)
import numpy as np
def f1(v):
k = np.arrange(v.shape[0])
if k != v:
return False
else:
return True
def f2(u,v):
return u[:,:]+v[:,::-1]
def f3(M,v):
ans = np.dot(M,np.array(v))
return ans
for k in range(int(input())):
exec(input().strip())
| # 0998, 2022-04-28 08:13:06, xx- (0%)
import numpy as np
def f1(v):
k = np.arrange(v.shape[0])
if k != v:
return False
else:
return True
def f2(u,v):
return u[:,:]+v[::-1,:]
def f3(M,v):
ans = np.dot(M,np.array(v))
return ans
for k in range(int(input())):
exec(input().strip())
| # 0999, 2022-04-28 08:13:21, xx- (0%)
import numpy as np
def f1(v):
k = np.arrange(v.shape[0])
if k != v:
return False
else:
return True
def f2(u,v):
return u[:,:]+v[:,::-1]
def f3(M,v):
ans = np.dot(M,np.array(v))
return ans
for k in range(int(input())):
exec(input().strip())
| # 1000, 2022-04-28 08:16:02, --- (0%)
import numpy as np
def f1(v):
k = np.arrange(v.shape[0])
if k != v:
return False
else:
return True
def f2(u,v):
return u[:,:]+v[:,::-1]
def f3(M,v):
ans = np.dot(M,np.array(v))
return ans
exec(input().strip())
|
# 1001, 2022-04-28 08:10:20, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
op = v == 0
return op
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
op = u+v[n-2]
return op
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1] A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
| # 1002, 2022-04-28 08:12:03, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
op = v == 0
return op
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
op = u+v[n-2]
return op
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1] A = []
a = M[:]
return a*v
| # 1003, 2022-04-28 08:15:37, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
idxx = np.arange(v.shape[0])
op = np.sum(idxx==v) == len(v)
return op
def f2(u, v):
# u and v are 1-D numpy array of equal size
idxx = np.arange(u.shape[0])
a = v[u.shape[0]-pos-1]
op = u[idxx] +a
return op
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1] A = []
a = M[:]
return a*v
| # 1004, 2022-04-28 08:16:36, --- (0%) import numpy as np def f1(v): # v: 1-D numpy array idxx = np.arange(v.shape[0]) op = np.sum(idxx==v) == len(v) return op def f2(u, v): # u and v are 1-D numpy array of equal size idxx = np.arange(u.shape[0]) a = v[u.shape[0]-pos-1] op = u[idxx] +a return op def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] A = [] a = M[:] return a*v |
# 1005, 2022-04-28 08:12:25, -xx (0%) import numpy as np def f1(v): # v: 1-D numpy array p=v == v.shape[0] return p for k in range(int(input())): exec(input().strip()) | # 1006, 2022-04-28 08:14:01, -xx (0%) import numpy as np def f1(v): # v: 1-D numpy array p=v != v.shape[0] return p for k in range(int(input())): exec(input().strip()) | # 1007, 2022-04-28 08:14:48, -xx (0%) import numpy as np def f1(v): # v: 1-D numpy array p= np.array(v) != np.array(v).shape[0] return p for k in range(int(input())): exec(input().strip()) | # 1008, 2022-04-28 08:17:07, --- (0%) import numpy as np def f1(v): # v: 1-D numpy array p= np.array(v) != np.array(v).shape[0] return p |
# 1009, 2022-04-28 08:14:45, x-x (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
for i in range(v.shape[0]):
if v[i] != i: return False
return True
c=np.array(v.shape[0])
x= (v ==c)
if x.size == v.size:
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]#row
return np.array([u+v[-1::-1]])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 1010, 2022-04-28 08:15:14, x-x (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
for i in range(v.shape[0]):
if v[i] != i: return False
return True
c=np.array(v.shape[0])
x= (v ==c)
if x.size == v.size:
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]#row
return np.array([u+v[-1::-1]])
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 1011, 2022-04-28 08:15:33, --x (0%)
import numpy as np
def f1(v):
c=np.array(v.shape[0])
x= (v ==c)
if x.size == v.size:
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]#row
return np.array([u+v[-1::-1]])
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 1012, 2022-04-28 08:15:50, --x (0%)
import numpy as np
def f1(v):
c=np.array(v.shape[0])
x= (v ==c)
if x.size == v.size:
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]#row
return np.array([u+v[-1::-1]])
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 1013, 2022-04-28 08:04:27, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i = np.arange(v.shape[0])
if v[i] != i :
return False
return True
| # 1014, 2022-04-28 08:12:50, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i = np.arange(v.shape[0])
if v[i] != i :
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
a= []
a.append(M * v)
A.append(a)
return np.array(A)
| # 1015, 2022-04-28 08:14:28, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i = np.arange(v.shape[0])
if v[i] != i :
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
ans = [u[i]+v[:-1]]
return np.array( x )
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
a= []
a.append(M * v)
A.append(a)
return np.array(A)
| # 1016, 2022-04-28 08:17:07, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
i = np.arange(v.shape[0])
if v[i] != i :
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
ans = [u[i]+v[:-1]]
return np.array( x )
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
a= []
a.append(M * v)
A.append(a)
return np.array(A)
|
# 1017, 2022-04-28 08:09:31, compilation error (0%) import numpy as np def f1(v): # v: 1-D numpy array b = np.array((0,i)) b = v.shape[0] != b return False return True def f2(u, v): # u and v are 1-D numpy array of equal size def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 1018, 2022-04-28 08:12:57, compilation error (0%) import numpy as np def f1(v): # v: 1-D numpy array b = np.array((0,i)) b = v.shape[0] != b if v[i] != i : return False return True def f2(u, v): # u and v are 1-D numpy array of equal size def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 1019, 2022-04-28 08:13:38, compilation error (0%) import numpy as np def f1(v): # v: 1-D numpy array b = np.array((0,i)) b = v.shape[0] != b if v[i] != i : return False return True def f2(u, v): # u and v are 1-D numpy array of equal size def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 1020, 2022-04-28 08:16:07, compilation error (0%) import numpy as np def f1(v): # v: 1-D numpy array b = np.array((0,i)) if v.shape[0] != b : return False return True def f2(u, v): # u and v are 1-D numpy array of equal size def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) |
# 1021, 2022-04-28 08:06:55, --- (0%) import numpy as np def f1(v): pos = np.arange(len(v)) return np.sum(pos[v == pos]) def f2(u,v): return u+v | # 1022, 2022-04-28 08:07:12, --- (0%) import numpy as np def f1(v): pos = np.arange(len(v)) return np.sum(pos[v == pos]) def f2(u,v): return u+v #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 1023, 2022-04-28 08:14:06, --- (0%) import numpy as np def f1(v): pos = np.arange(len(v)) return np.sum(pos[v == pos]) def f2(u,v): pos = np.arange(len(v)) return u + v[-pos] #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 1024, 2022-04-28 08:16:59, --- (0%)
import numpy as np
def f1(v):
pos = np.arange(len(v))
s = np.sum(pos[v != pos])
if s != 0:
return False
return True
def f2(u,v):
pos = np.arange(len(v))
return u + v[-pos]
#----- DON'T modify any of the following lines ----- for k in range(int(input())):
exec(input().strip())
|
# 1025, 2022-04-28 08:06:55, --- (0%)
import numpy as np
def f1(v):
index = np.arange(v.shape[0])
return v != index
def f2(u,v):
n = u.shape[0]
return np.dot(u,v)
def f3(M,v):
return M * v
| # 1026, 2022-04-28 08:13:30, compilation error (0%)
import numpy as np
def f1(v):
left = v[:-2]
mid = v[1:-1]
right = v[2:]
pos = np.arange(len(mid))
ch = pos[(mid - left == 1) & (right - mid == 1)]
if sum(ch) = len(mid):
return True
return False
def f2(u,v):
n = u.shape[0]
pos = np.arange(n)
return np.dot(u,v)
def f3(M,v):
return v * M
| # 1027, 2022-04-28 08:14:20, compilation error (0%)
import numpy as np
def f1(v):
left = v[:-2]
mid = v[1:-1]
right = v[2:]
pos = np.arange(len(mid))
ch = pos[(mid - left == 1) & (right - mid == 1)]
if sum(ch) = len(mid):
return True
return False
def f2(u,v):
n = u.shape[0]
pos = np.arange(n)
return np.dot(u,v)
def f3(M,v):
return v * M
for k in range(int(input())):
exec(input().strip())
| # 1028, 2022-04-28 08:14:55, compilation error (0%)
import numpy as np
def f1(v):
left = v[:-2]
mid = v[1:-1]
right = v[2:]
pos = np.arange(len(mid))
ch = pos[(mid - left == 1) & (right - mid == 1)]
if sum(ch) = len(mid):
return True
return False
def f2(u,v):
n = u.shape[0]
pos = np.arange(n)
return np.dot(u,v)
def f3(M,v):
return v * M
for k in range(int(input())):
exec(input().strip())
|
# 1029, 2022-04-28 08:09:20, xx- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if v[i] != i: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
pos = np.arange(1,x.shape[0]-1,)
return u[:] + v[len(u)-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.dot(M,v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 1030, 2022-04-28 08:11:08, xx- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if v[i] != i: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
pos = np.arange(1,x.shape[0]-1,)
return u[:] + v[len(u)-1::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.dot(M,v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 1031, 2022-04-28 08:12:07, xx- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(1,x.shape[0]-1,)
if v[:] != pos[:]: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
pos = np.arange(1,x.shape[0]-1,)
return u[:] + v[len(u)-1::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.dot(M,v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 1032, 2022-04-28 08:14:58, xx- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
pos = np.arange(1,x.shape[0]-1,)
if v[:] != pos[:]: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
pos = np.arange(1,x.shape[0]-1,)
return u[:] + v[len(u)-1:-1:-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.dot(M,v)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 1033, 2022-04-28 08:09:55, -xx (0%)
import numpy as np
def f1(v):
x = np.arange(0,v.shape[0],1)
y = v[v == x]
z = np.sum(y)
if z == 0 :
return False
else:
return True
def f2(u, v):
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
for k in range(int(input())):
exec(input().strip())
| # 1034, 2022-04-28 08:10:43, -xx (0%)
import numpy as np
def f1(v):
x = np.arange(0,v.shape[0],1)
y = v == x
z = np.sum(y)
if z == 0 :
return False
else:
return True
def f2(u, v):
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
for k in range(int(input())):
exec(input().strip())
| # 1035, 2022-04-28 08:11:43, compilation error (0%)
import numpy as np
def f1(v):
x = np.arange(0,v.shape[0],1)
y = v == x
z = np.sum(y)
if z == 0 :
return False
else:
return True
def f2(u, v):
n = u.shape[0]
x = np.arange(0,v.shape[0],1)
return np.array([u[x]+v[n-x-1])
def f3(M, v):
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
for k in range(int(input())):
exec(input().strip())
| # 1036, 2022-04-28 08:13:31, compilation error (0%)
import numpy as np
def f1(v):
x = np.arange(0,v.shape[0],1)
y = v == x
z = np.sum(y)
if z == 0 :
return False
else:
return True
def f2(u, v):
n = u.shape[0]
x = np.arange(0,v.shape[0],1)
return np.array([u[x]+v[n-x-1])
def f3(M, v):
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
for k in range(int(input())):
exec(input().strip())
|
# 1037, 2022-04-28 08:11:45, xx- (0%)
import numpy as np
def f1(v):
x = np.arange(0, v.shape[0], 1)
y = v[::,:1:]
m = y == x
return npmin.m
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
f = u[i]+v[::-1]
return f
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
f = M.dot(v)
return f
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 1038, 2022-04-28 08:12:01, xx- (0%)
import numpy as np
def f1(v):
x = np.arange(0, v.shape[0], 1)
y = v[::,:1:]
m = y == x
return npmin.m
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
f = u[i]+v[::-1]
return f
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
f = M.dot(v)
return f
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 1039, 2022-04-28 08:12:52, xx- (0%)
import numpy as np
def f1(v):
x = np.arange(0, v.shape[0])
y = v
m = y == x
return npmin.m
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
f = u[i]+v[::-1]
return f
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
f = M.dot(v)
return f
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 1040, 2022-04-28 08:14:44, xx- (0%)
import numpy as np
def f1(v):
x = np.arange(0, v.shape[0])
y = v
m = y == x
return npmin(m)
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
f = u[i]+v[::-1]
return f
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
f = M.dot(v)
return f
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 1041, 2022-04-28 08:05:45, --- (0%)
def f1(v):
# v: 1-D numpy array
#for i in range(v.shape[0]):
#if v[i] != i: return False
#return True
a=np.arange(v.shape[0])
if v[a]==a:
return False
return True
| # 1042, 2022-04-28 08:06:33, --- (0%)
def f1(v):
# v: 1-D numpy array
#for i in range(v.shape[0]):
#if v[i] != i: return False
#return True
a=np.arange(v.shape[0])
if v[a]!=a:
return False
return True
| # 1043, 2022-04-28 08:11:54, --- (0%)
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
i=np.arange(n)
return np.array([u[i]+v[n-i-1] ])
|
# 1044, 2022-04-28 08:15:17, xxx (0%)
def f1(v):
# v: 1-D numpy array
v = np.array([1,2,3,4])
a = list(range(v.shape[0]))
return v==a
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 1045, 2022-04-28 08:16:54, xxx (0%)
def f1(v):
# v: 1-D numpy array
v = np.array([1,2,3,4])
a = list(range(v.shape[0]))
return v==a
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return m*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 1046, 2022-04-28 08:17:06, xxx (0%)
def f1(v):
# v: 1-D numpy array
v = np.array([1,2,3,4])
a = list(range(v.shape[0]))
return v==a
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return m*v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 1047, 2022-04-28 08:14:33, compilation error (0%) import numpy as np def f1(v): # v: 1-D numpy array a = np.arange(v.shape[0]) return a != v def f2(u, v): # u and v are 1-D numpy array of equal size def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 1048, 2022-04-28 08:15:31, compilation error (0%) import numpy as np def f1(v): # v: 1-D numpy array a = np.arange(v.shape[0]) return a = v def f2(u, v): # u and v are 1-D numpy array of equal size def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 1049, 2022-04-28 08:17:03, compilation error (0%) import numpy as np def f1(v): # v: 1-D numpy array a = np.arange(v.shape[0]) return a = v def f2(u, v): # u and v are 1-D numpy array of equal size u = u[::-1] return (u+v)[::-1] def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) |
# 1050, 2022-04-28 08:14:36, compilation error (0%)
def f1(v):
a = len(v)
new = np.arange(a)
if np.all(new) != np.all(v):
return False
return True
for k in range(int(input())):
exec(input().strip())
| # 1051, 2022-04-28 08:16:29, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
for i in range(v.shape[0]):
if v[i] != i: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array(v[::-1] +u)
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1] A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j]) A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines ----- for k in range(int(input())):
exec(input().strip())
| # 1052, 2022-04-28 08:16:57, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
for i in range(v.shape[0]):
if v[i] != i: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array(v[::-1] +u)
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1] A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j]) A.append(a)
return M*v
#----- DON'T modify any of the following lines ----- for k in range(int(input())):
exec(input().strip())
|
# 1053, 2022-04-28 08:14:24, compilation error (0%)
import numpy as np
v = np.array([[0],
[1],
[2],
[3],])
def f1(v):
# v: 1-D numpy array
#v = v.T
x = [v[:].shape[0]==v[:]]
=
if False in x:
retrun False
return True
#v[:][]
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
print(f1(v))
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 1054, 2022-04-28 08:14:34, compilation error (0%)
import numpy as np
v = np.array([[0],
[1],
[2],
[3],])
def f1(v):
# v: 1-D numpy array
#v = v.T
x = [v[:].shape[0]==v[:]]
if False in x:
retrun False
return True
#v[:][]
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
print(f1(v))
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 1055, 2022-04-28 08:14:43, xxx (0%)
import numpy as np
v = np.array([[0],
[1],
[2],
[3],])
def f1(v):
# v: 1-D numpy array
#v = v.T
x = [v[:].shape[0]==v[:]]
if False in x:
return False
return True
#v[:][]
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
print(f1(v))
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 1056, 2022-04-28 08:09:31, --- (0%)
import numpy as np
def f1(v):
i=np.arange(v.shape[0])
return v.shape==i.shape and np.sum(v!=i)==0
def f2(u, v):
vv=v[-1::-1,:]
return u+vv
def f3(M, v):
return np.dot(M,v)
| # 1057, 2022-04-28 08:14:58, --- (0%)
import numpy as np
def f1(v):
i=np.arange(v.shape[0])
return v.shape==i.shape and np.sum(v!=i)==0
def f2(u, v):
vv=v[-1::-1,:]
return u+vv
def f3(M, v):
return np.dot(M,v)
| # 1058, 2022-04-28 08:15:20, --- (0%)
import numpy as np
def f1(v):
i=np.arange(v.shape[0])
return v.shape==i.shape and np.sum(v!=i)==0
def f2(u, v):
vv=v[-1::-1]
return u+vv
def f3(M, v):
return np.dot(M,v)
|
# 1059, 2022-04-28 08:10:02, -xx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
index = np.arange(v.shape[0]) #(0,1,2)
if False not in index[v==index] :
return True
else :
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 1060, 2022-04-28 08:12:59, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
index = np.arange(v.shape[0]) #(0,1,2)
if False not in v==index :
return True
else :
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 1061, 2022-04-28 08:15:38, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
index = np.arange(v.shape[0]) #(0,1,2)
if False not in v==index :
return True
else :
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 1062, 2022-04-28 08:10:26, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if v==v.shape[0] :
return True
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array(u[0::]+v[n-i-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 1063, 2022-04-28 08:12:14, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if v==v.shape[0] :
return True
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array(u[0::]+v[(range(v.shape[0]-1,0,-1))])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 1064, 2022-04-28 08:14:49, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
n = v[v==v.shape[0]]
if v[0::] :
return True
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array(u[0::]+v[(range(v.shape[0]-1,0,-1))])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 1065, 2022-04-28 08:08:38, compilation error (0%) import numpy as np def f1(v): # v: 1-D numpy array for i in range(v.shape[0]): if v[i] != i: return False return True def f2(u, v): # u and v are 1-D numpy array of equal size n = u.shape[0] return np.array([u[i]+v[n-i-1] for i in range(n)]) def f3(M, v): # M: 2-D numpy array # v: 1-D numpy array # note: v.shape[0] equals to M.shape[1] A = [] for i in range(M.shape[0]): a = [] for j in range(M.shape[1]): a.append(M[i,j] * v[j]) A.append(a) return np.array(A) #----- DON'T modify any of the following lines ----- for k in range(int(input())): exec(input().strip()) | # 1066, 2022-04-28 08:09:38, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
for i in range(v.shape[0]):
if v[i] != i: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 1067, 2022-04-28 08:10:34, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
for i in range(v.shape[0]):
if v[i] != i: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 1068, 2022-04-28 08:08:49, --- (0%)
def f1(v):
# v: 1-D numpy array
h = np.arange(len(v))
true_ = v[(v != h) == True]
if np.sum(true_,axis = 1) == 0:
return True
else:
return False
return h , true_
exec(input().strip())
| # 1069, 2022-04-28 08:14:44, --- (0%)
def f1(v):
# v: 1-D numpy array
h = np.arange(len(v))
true_ = v[(v != h) == True]
if np.sum(true_,axis = 1) == 0:
return True
else:
return False
def f2(u,v):
return np.array(u[:] + v[::-1])
def f3(M, v):
n = M.shape[0]
m = M.shape[1]
A = M[:n,:m]
return A
exec(input().strip())
|
# 1070, 2022-04-28 08:10:12, xxx (0%)
def f1(v):
# v: 1-D numpy array
pos = np.arange(v.shape[0])
if v[::] == pos:
return True
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
k = np.array[u[::]+v[n-1::-1]]
return k
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
k = np.sum(M,axis=0)
n = v+k
return n
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 1071, 2022-04-28 08:12:14, xxx (0%)
def f1(v):
# v: 1-D numpy array
pos = np.arange(v.shape[0])
if v == pos:
return True
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
k = np.array[u[::]+v[n-1::-1]]
return k
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
k = np.sum(M,axis=0)
n = v+k
return n
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 1072, 2022-04-28 08:10:30, --- (0%)
import numpy as np
def f1(v):
return v.shape[0]==v.shape[1]
def f2(u, v):
return u[:,:]+v[::-1,:]
| # 1073, 2022-04-28 08:12:52, --- (0%)
import numpy as np
def f1(v):
return v.shape[0]==v.shape[1]
def f2(u, v):
return u[:,:]+v[::-1,:]
def f3(M, v):
return M*v
|
# 1074, 2022-04-28 08:13:24, -xx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(v.shape[0])
c = a==v
return c
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 1075, 2022-04-28 08:14:28, -xx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(v.shape[0])
c = a==v
return c
def f2(u, v):
# u and v are 1-D numpy array of equal size
pass
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
pass
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 1076, 2022-04-28 08:03:59, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
for i in range(v.shape[0]):
if v[i] != i: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 1077, 2022-04-28 08:06:22, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
for i in range(v.shape[0]):
if v[i] != i: return not True
return not False
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-1-i] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 1078, 2022-04-28 08:12:41, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if np.sum(np.arange(0,len(v[0]))) != np.sum(v) :
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
pass
def f3(M, v):
pass
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 1079, 2022-04-28 08:15:33, -xx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
if np.sum(np.arange(0,len(v)) != np.sum(v)) :
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
pass
def f3(M, v):
pass
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 1080, 2022-04-28 08:15:28, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
#for i in range(v.shape[0]):
#if v[i] != i: return False
a = np.nrange(v.shape[0])
if v != a :
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 1081, 2022-04-28 08:15:47, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
#for i in range(v.shape[0]):
#if v[i] != i: return False
a = np.arange(v.shape[0])
if v != a :
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 1082, 2022-04-28 08:10:31, xxx (0%)
def f1(v):
if len(v) != 1:
return False
return True
def f2(u, v):
v = list(v)
v.append(v[0])
v = v[1:len(v)]
summ = u+v
return u+v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 1083, 2022-04-28 08:15:12, xxx (0%)
def f1(v):
if len(v) != 1:
return False
return True
def f2(u, v):
v = list(v)
v.append(v[0])
v = v[1:len(v)]
summ = u+v
return u+v
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 1084, 2022-04-28 08:14:14, -xx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x = np.arange(0,v.shape[0],1)
e = np.array(v != x)
if np.sum(e) == 0:
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
vrr = v[0:len(v):-1]
ans = vrr + u
return ans
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 1085, 2022-04-28 08:16:56, -xx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
x = np.arange(0,v.shape[0],1)
e = np.array(v != x)
if np.sum(e) == 0:
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
vrr = v[0:len(v):-1]
ans = vrr + u
return ans
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return []
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 1086, 2022-04-28 08:11:25, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
for i in range(v.shape[0]):
if v[i] != i: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A=M*V
return A
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 1087, 2022-04-28 08:11:52, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
for i in range(v.shape[0]):
if v[i] != i: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A=M*V
return A
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 1088, 2022-04-28 08:08:57, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
v = np.array(v)
x = np.arange(v)
s = np.sum(v==x)
if s == 0: return True
else: return False
| # 1089, 2022-04-28 08:10:23, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
v = np.array(v)
x = np.arange(v)
s = np.sum(v==x)
if s == 0: return False
else: return True
|
# 1090, 2022-04-28 08:12:43, -xx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
indexv=np.arange(v.shape[0])
return v==indexv
def f2(u, v):
# u and v are 1-D numpy array of equal size
return
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 1091, 2022-04-28 08:16:19, -xx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
indexv=np.arange(v.shape[0])
v=v==indexv
s=np.sum(v)
if s==0:
return True
else:
return False
def f2(u, v):
# u and v are 1-D numpy array of equal size
return
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 1092, 2022-04-28 08:14:37, xxx (0%)
import numpy as np
#shape = np.array([[0,0,0],[1,0,1],[2,2,2]])
def f1(v):
# v: 1-D numpy array
#for i in range(v.shape[0]):
#if v[i] != i: return False
#return True
return sum(v[v == v[::,0]]) == np.sum(v,axis=0)
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
print(f1(shape))
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 1093, 2022-04-28 08:14:49, xxx (0%)
import numpy as np
#shape = np.array([[0,0,0],[1,0,1],[2,2,2]])
def f1(v):
# v: 1-D numpy array
#for i in range(v.shape[0]):
#if v[i] != i: return False
#return True
return sum(v[v == v[::,0]]) == np.sum(v,axis=0)
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
print(f1(shape))
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 1094, 2022-04-28 08:05:03, xxx (0%) import numpy as np def f1(v): # v: 1-D numpy array n = v.shape[0] if v[i] != i: return False return True for k in range(int(input())): exec(input().strip()) | # 1095, 2022-04-28 08:10:26, xxx (0%) import numpy as np def f1(v): # v: 1-D numpy array n = v.shape[0] if v[:,:] != i: return False return True for k in range(int(input())): exec(input().strip()) |
# 1096, 2022-04-28 08:15:15, xxx (0%)
import numpy as np
def f1(v):
return not(sum(sum(v!=1))>0)
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 1097, 2022-04-28 08:17:10, xxx (0%)
import numpy as np
def f1(v):
return not(sum(sum(v!=1))>0)
def f2(u, v):
# u and v are 1-D numpy array of equal size
return [u[:]+v[::-1]]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 1098, 2022-04-28 08:15:57, compilation error (0%)
import numpy as np
def f1(v):
return v[v==v]
def f2(u, v):
n = u.shape[0]
v_new=v[n-1:0]+v[-1]
return np.array([u+v_new])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
for k in range(int(input())):
exec(input().strip())
| # 1099, 2022-04-28 08:16:03, compilation error (0%)
import numpy as np
def f1(v):
return v[v==v]
def f2(u, v):
n = u.shape[0]
v_new=v[n-1:0]+v[-1]
return np.array([u+v_new])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
for k in range(int(input())):
exec(input().strip())
|
# 1100, 2022-04-28 08:13:52, xxx (0%)
def f1(v):
mango = v.shape[0]
yes = mango[mango != v.shape[0]]
return yes
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 1101, 2022-04-28 08:15:26, --- (0%)
def f1(v):
mango = v.shape[0]
yes = mango[mango != v.shape[0]]
return yes
|
# 1102, 2022-04-28 08:14:50, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
vv = np.arrange(v)
n = len(vv.shape)
t = vv[n>vv]
return t
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 1103, 2022-04-28 08:15:18, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
vv = np.arrange(v)
n = len(vv.shape)
t = vv[n>vv]
return t
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 1104, 2022-04-28 08:02:05, xxx (0%)
def f1(v):
# v: 1-D numpy array
for i in range(v.shape[0]):
if v[i] != i: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
| # 1105, 2022-04-28 08:13:34, xxx (0%)
def f1(v):
# v: 1-D numpy array
for i in range(v.shape[0]):
if v[i] != i: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
f2 = u.shape[0]
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 1106, 2022-04-28 08:13:30, --- (0%)
import numpy as np
def f1(v):
pass
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u + v
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = np.dot(M,v)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 1107, 2022-04-28 08:15:48, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
range=np.arange(v.shape[0])
return v[::]!=range[::]
def f2(u, v):
# u and v are 1-D numpy array of equal size
return np.array([u[::]+v[::-1]])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.array([M[::,::]*v[::]])
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 1108, 2022-04-28 08:09:19, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
for i in range(v.shape[0]):
if v[i] != i: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
for
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 1109, 2022-04-28 08:15:55, --- (0%) import numpy as np def f1(v): x=np.arange(len(v)) return x[v!=x] |
# 1110, 2022-04-28 08:10:24, xxx (0%)
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u+v[n-1]])
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 1111, 2022-04-28 08:15:24, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(len(v))
b = a[1]
return v
def f2(u, v):
# u and v are 1-D numpy array of equal size
#n = u.shape[0]
#return np.array([u[i]+v[n-i-1] for i in range(n)])
# v [0,1,2,3,4] ---> [3,2,1,0,4]
c = list(v)
c = c[len(c)-2:0:-1] + c[0:1] + c[-1:-2:-1]
return u + np.array(c)
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 1112, 2022-04-28 08:10:17, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
return np.arange(v.shape[0])
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u + v[::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return np.dot(v, M)
|
# 1113, 2022-04-28 08:15:12, -xx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
e = np.arange(v.shape[0])
a = e==v
return a
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 1114, 2022-04-28 08:15:32, xxx (0%)
from typing import ParamSpecArgs
import numpy as np
def f1(v):
n = v.shape[0]
indexing = np.arange(n)
diff = abs(n-indexing)
mini = np.min(diff)
return (mini == 0)
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = v.shape[0]
id = np.arange(n)
#i = id//n , j = id - n*i
id = id+n-2*(id-n*(id//n))-1
newv = v[id]
return u+newv
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
pass
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 1115, 2022-04-28 08:16:20, -xx (0%)
import numpy as np
def f1(v):
pros=np.arange(v.shape[0])
if np.sum(v[v==pros])==v.shape[0]: return True
return False
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 1116, 2022-04-28 08:14:39, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
p = np.arange(0,v.shape[0],1)
tf = p == v
s = np.sum(tf,axis=0)
if s != v.shape[0]:
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u + v[-2::-1]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
# #----- DON'T modify any of the following lines -----
# for k in range(int(input())):
exec(input().strip())
|
# 1117, 2022-04-28 08:15:26, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.sum[v != i]
if a > 0:
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal siz
a = v[n-1::-1]
return u + a
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
a = v.reshape((v.shape[0],1))
return a*M
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 1118, 2022-04-28 08:15:57, -xx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
row_index = np.arange(v.shape[0])
ans = (row_index == v)
return ans
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 1119, 2022-04-28 08:15:53, xxx (0%)
import numpy as np
def f1(v):
A1,A2=v.shape
A=np.arange(A1)
B=v&A
C=np.min(B)
if C==False :return False
return True
def f2(u,v):
n=u.shape[0]
pass
def f3(M,v):
pass
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 1120, 2022-04-28 08:15:45, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
for i in range(v.shape[0]):
if v[i] != i: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
|
# 1121, 2022-04-28 08:14:22, -xx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
# return (np.arange(v.shape[0]) == v)
return v[0] == 0
for i in range(v.shape[0]):
if v[i] != i:
return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u + v[::-1]
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return M*v
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i, j] * v[j])
A.append(a)
return np.array(A)
# print(f3(np.array([[10, 1, 6], [1, 2, 3]]), np.array([10, 11, 16])))
# ----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 1122, 2022-04-28 08:15:12, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
# for i in range(v.shape[0]):
# if v[i] != i: return False
# return True
if v[:,:] != v[:,:]: return False
else : return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
# n = u.shape[0]
# return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
# A = []
# for i in range(M.shape[0]):
# a = []
# for j in range(M.shape[1]):
# a.append(M[i,j] * v[j])
# A.append(a)
# return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 1123, 2022-04-28 08:11:14, --- (0%) import numpy as np def f1(v): # v: 1-D numpy array pros=np.arange(V.shape[0]) d=v==pros return d exec(input().strip()) |
# 1124, 2022-04-28 08:16:39, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
index=np.arange(v.shape[0])
return np.sum(v == index) == v.shape[0]
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u+v[::-1]
|
# 1125, 2022-04-28 08:14:28, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
index=np.arange(v.shape[0])
return np.sum(v == index) == v.shape[0]
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return u+v[::-1]
|
# 1126, 2022-04-28 08:13:01, xxx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
for i in range(v.shape[0]):
if v[i] != i: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 1127, 2022-04-28 08:15:03, xxx (0%)
def f1(v):
return np.all(v == np.arange(v.shape[0]))
def f2(u, b):
n = u.shape[0]
return u + b[n-1::-1]
def f3(M, v):
return np.dot(M, v)
for k in range(int(input())):
exec(input().strip())
|
# 1128, 2022-04-28 08:15:37, compilation error (0%)
import numpy as np
def f1(v):
v = v.shape[0]
v = (v[:v.shape[0]:] = :shape[0]:).tolist
# v: 1-D numpy array
#for i in range(v.shape[0]):
#if v[i] != i:
#return False
#return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
v = np.array(n)
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
|
# 1129, 2022-04-28 08:14:34, xxx (0%)
import numpy as np
def f1(v):
v1 = np.sum(v,axis=1)
v = v == v1
if v[i] != i:
return False
else:
return True
# v: 1-D numpy array
#for i in range(v.shape[0]):
#if v[i] != i: return False
#return True
def f2(u, v):
v = v[::,u.shape[0]-1::]
r = u + v
return r
# u and v are 1-D numpy array of equal size
#n = u.shape[0]
#return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 1130, 2022-04-28 08:13:01, -xx (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
num=np.arange(v.shape[0])
answer=(v==num)
return answer
#----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|
# 1131, 2022-04-28 08:14:30, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
#return v[[0,1,2],:]== 2
for i in range(v.shape[0]):
if v[i] != i: return False
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
return u[:]+v[::-1,]
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
|
# 1132, 2022-04-28 08:15:42, --- (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
b=v.shape[1]
x=np.arange(b)
c= (v[v==x])
if c.shape[0]!=x:
return False
else:
return True
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array([u[i]+v[n-i-1] for i in range(n)])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
A = []
for i in range(M.shape[0]):
a = []
for j in range(M.shape[1]):
a.append(M[i,j] * v[j])
A.append(a)
return np.array(A)
|
# 1133, 2022-04-28 08:15:26, compilation error (0%)
import numpy as np
def f1(v):
# v: 1-D numpy array
a = np.arange(0,v.shape[0])
return all(a==v)
def f2(u, v):
# u and v are 1-D numpy array of equal size
n = u.shape[0]
return np.array(u+v[::-1])
def f3(M, v):
# M: 2-D numpy array
# v: 1-D numpy array
# note: v.shape[0] equals to M.shape[1]
return (M*v)[:,0].reshape((M.shape[0],1))
----- DON'T modify any of the following lines -----
for k in range(int(input())):
exec(input().strip())
|