defmain(): n = int(input()) dat = list(map(float, input().split())) mean = sum(dat) / n deviation = (sum((a - mean) ** 2for a in dat) / n) ** 0.5 dat = list((a - mean) / deviation for a in dat) print(" ".join(map(str, dat))) main()
intmain(){ int n; scanf("%d", &n); for (int i = 0; i < n; ++i) { scanf("%d", &dat[i]); } double mean = .0, dev = .0; for (int i = 0; i < n; ++i) mean += dat[i]; mean /= n; for (int i = 0; i < n; ++i) dev += pow(dat[i] - mean, 2); dev = pow(dev / n, 0.5); for (int i = 0; i < n; ++i) { printf("%f\n", (dat[i] - mean) / dev); } return0; }
defmatch(A, B, x, y, L): """在 (x, y) 进行地图匹配 Args: A (set): 存储树的坐标的集合 B (List): 藏宝图 x (int): 坐标 y (int): 坐标 """ for i, row inenumerate(B): for j, c inenumerate(row): ifnot0 <= x + i <= L and0 <= y + j <= L: returnFalse true_loc = loc2num(x + i, y + j) if c == 1and true_loc in A: continue elif c == 0and true_loc notin A: continue else: returnFalse returnTrue
defmain(): n, L, S = map(int, input().split()) A = [tuple(map(int, input().split())) for _ inrange(n)] B = [list(map(int, input().split())) for _ inrange(S + 1)] B.reverse() tree = {loc2num(x, y) for x, y in A} print(sum(match(tree, B, x, y, L) for x, y in A)) main()
int n, L, S; int A[1007][2], B[55][55]; unordered_set<ll> tree;
voidget_A(){ for (int i = 0; i < n; ++i) { scanf("%d %d", &A[i][0], &A[i][1]); } }
voidget_B(){ for (int i = 0; i <= S; ++i) { for (int j = 0; j <= S; ++j) { scanf("%d", &B[S - i][j]); } } }
ll loc2num(int x, int y){ ll ans = x; return ans * MOD + y; }
boolmatch(int x, int y){ for (int i = 0; i <= S; ++i) { for (int j = 0; j <= S; ++j) { int a = x + i, b = y + j; if (a < 0 || a > L || b < 0 || b > L) returnfalse; ll key = loc2num(a, b); if (B[i][j] == 0 && tree.find(key) == tree.end()) continue; elseif (B[i][j] == 1 && tree.find(key) != tree.end()) continue; else returnfalse; } } returntrue; }
intmain(){ scanf("%d %d %d", &n, &L, &S);
get_A(); get_B();
for (int i = 0; i < n; ++i) { tree.emplace(loc2num(A[i][0], A[i][1])); }
int cnt = 0; for (int i = 0; i < n; ++i) { if (match(A[i][0], A[i][1])) ++cnt; }
为了响应国家发展新基建的倡议，西西艾弗岛上兴建了西西艾弗数据中心，并以此为基础运营了西西艾弗云。作为数据中心的运营和维护方，
西西艾弗云公司十分重视西西艾弗云的网络安全管理工作。众所周知，安全性和便捷性难以兼得，同时，
一个混乱的权限模型可能会导致人员被授予不必要的权限，从而造成安全风险。因此在西西艾弗云公司的网络安全部工作的小
C 专门设计了一种科学的权限模型。
2ns
个字符串，每两个表示授权对象清单中的授权对象，前一个字符串为
u 或
g，分别表示这个授权对象是一个用户名称或者用户组名称，后一个字符串为用户名称或者用户组名称。
输入接下来的 q
行中，每行表示一个待授权的行为，包括空格分隔的若干元素，依次为：
一个字符串，表示执行该操作的用户名称；
一个正整数 ng，表示该用户所属的用户组的数量；
ng
个字符串，依次表示该用户所属的用户组的名称；
一个字符串，表示待查操作的名称；
一个字符串，表示被操作的资源种类；
一个字符串，表示被操作的资源名称。
输出格式
输出到标准输出。
输出 q
行，每行表示一个操作是否可以被执行，0
表示不能执行，1 表示可以执行。
样例输入
1 2 3 4 5 6 7
1 2 3 op 1 open 1 door 0 op 1 g sre op 1 u xiaop xiaoc 2 sre ops open door room302 xiaop 1 ops open door room501 xiaoc 2 sre ops remove door room302
样例输出
1 2 3
1 1 0
样例解释
在本例中，定义了一个名为 op 的角色，授予了对任意
door 类型的对象的 open
操作的权限，同时定义了两个指向 op 的角色关联。
注意，可以针对一个角色定义多于一个角色关联。本例给出了三个待授权的行为。其中，第一个行为，授权的主体用户是
xiaoc， 该用户所属的用户组 sre 被关联
op
角色，因此可以执行开门动作。第二个行为中，授权的主体用户是
xiaop， 该用户被直接关联了 op
角色，因此也可以执行开门动作。第三个行为中，授权的主体用户仍是
xiaoc，关联的角色仍为 op。但是， 由于
op 角色并未被授予 remove
操作的权限，因此该动作被拒绝。
子任务
对于 20% 的数据，有 n = m = 1，且给出的角色类似于题目正文中用于举例的
Admin，允许执行任何操作，且 nv = no = ns = ng = 1、nn = 0。
对于 40% 的数据，有 1 ≤ n, m ≤ 50，且 nv = no = ns = 1、ng ≤ 40、nn = 0。
self.name = next(info) nv = int(next(info)) self.op = set(next(info) for _ inrange(nv)) no = int(next(info)) self.source_type = set(next(info) for _ inrange(no)) nn = int(next(info)) self.source_name = set(next(info) for _ inrange(nn))
defget_role_link(info: str): """ 解析 角色关联 的输入 """ info = iter(info.split()) name = next(info) ns = int(next(info)) group = [(next(info), next(info)) for _ inrange(ns)] return name, group
defget_act(info: str): """ 解析 待授权的行为 的输入 """ info = iter(info.split()) user_name = next(info) ng = int(next(info)) group = [next(info) for _ inrange(ng)] op_name = next(info) source_type = next(info) source_name = next(info) return user_name, group, op_name, source_type, source_name
defget_role_list(roles: dict, users: dict, user_name: str, group: list): """ 获取用户及用户组对应的角色 """ r = users["u_" + user_name] for g in group: r = r | users["g_" + g] for rr in r: yield roles[rr]
defcheck_op(r: role, op, source_type, source_name) -> bool: """ 判断角色能否执行某个操作 """ # 1. 检查该角色的操作清单，如果该角色的操作清单中不包含该操作，且该角色的操作清单中也不包含字符串 `*`，那么不能执行该操作； if op notin r.op and'*'notin r.op: returnFalse # 2. 检查该角色的资源种类清单，如果该角色的资源种类清单中不包含该资源的种类，且该角色的资源种类清单中也不包含字符串 `*`，那么不能执行该操作； if source_type notin r.source_type and'*'notin r.source_type: returnFalse # 3. 检查该角色的资源名称清单，如果该角色的资源名称清单中不包含该资源的名称，且该角色的资源名称清单不是空数组，那么不能执行该操作； if source_name notin r.source_name and r.source_name: returnFalse returnTrue
defcheck_user(role_list, op_name, source_type, source_name) -> bool: """ 检测 role_list 中的角色能否执行操作 """ returnany(check_op(r, op_name, source_type, source_name) for r in role_list)
defmain(): # Get input n, m, q = map(int, input().split()) # n 个角色 roles = dict() for _ inrange(n): r = role(input()) roles[r.name] = r # m 个角色关联, 用哈希表做 用户/用户组 -> 角色 的映射 users = defaultdict(set) for _ inrange(m): role_name, group = get_role_link(input()) for user in group: users["_".join(user)].add(role_name) # q 个行为 for _ inrange(q): user_name, group, op_name, source_type, source_name = get_act(input()) if check_user(get_role_list(roles, users, user_name, group), op_name, source_type, source_name): print(1) else: print(0)
2 k：删除第 k
个操作插入的反射面，保证第 k
个操作发生在当前操作之前且为一个插入操作，且这个反射面还没有被删除；
3 x y d I t：在 (x, y)
位置放置一个光源，发射光线的方向为 d ，强度为 I ，求其所经 t
时刻后光线到达的坐标以及采样得到的光线强度。其中 d 的含义为：d = 0 表示沿 x 坐标增加的方向，d = 1 表示沿 y 坐标增加的方向，d = 2 表示沿 x 坐标减小的方向，d = 3 表示沿 y
坐标减小的方向。另外，保证光源不位于当前存在的某个反射面（不含端点）上。注意：如果
t
时刻后光线刚好到达某个反射面，则其强度取反射后的强度。
输入格式
从标准输入读入数据。
第 1 行，一个正整数 m 表示操作的总数量。
接下来 m
行，每行描述一个操作，格式如题目描述。
其中，除了所有的 a 和 I 以外的输入均为绝对值不超过 109 的整数，其中 k 和 t 为正整数；a 和 I 均为小数点后不超过 6 位的正实数，其中 a 在 0.2 ∼ 0.8之间， I ≤ 109。
输出格式
输出到标准输出。
对于每个查询操作输出一行，3
个整数，形如 x y I 表示激光最终到达的位置为 (x, y)
，采样得到的光线强度为 I
。特别地，如果采样到的光线强度为 0
（即光线已耗散），你也就无需关心最终到达的坐标，而只需要输出0 0 0即可。
from sortedcontainers import SortedList from collections import defaultdict
defget_mirror(info: list): """ 解析插入反射面 """ info = iter(info) _ = next(info) x1, y1, x2, y2 = map(int, (next(info) for _ inrange(4))) a = float(next(info)) return (x1, y1), (x2, y2), a
defget_remove(info): """ 解析移除反射面 """ two, k = info returnint(k)
defget_light(info): """ 解析添加光源 """ info = iter(info) _ = next(info) x, y, d = map(int, (next(info) for _ inrange(3))) i = float(next(info)) t = int(next(info)) return (x, y), d, i, t
defsearch_x_right(points_y: dict, x: int, y: int): """ 沿着 x 增加方向前进的最近反射点 """ cur: SortedList = points_y[y] ifnot cur: returnNone t = cur.bisect_left(x) if t >= len(cur): returnNone return cur[t]
defsearch_x_left(points_y: dict, x: int, y: int): """ 沿着 x 减小方向前进的最近反射点 """ cur: SortedList = points_y[y] ifnot cur: returnNone t = cur.bisect_left(x) - 1 if t == -1: returnNone return cur[t]
defsearch_y_down(points_x: dict, x: int, y: int): """ 沿着 y 减小方向前进的最近反射点 """ cur: SortedList = points_x[x] ifnot cur: returnNone t = cur.bisect_left(y) - 1 if t == -1: returnNone return cur[t]
defsearch_y_up(points_x: dict, x: int, y: int): """ 沿着 y 增加方向前进的最近反射点 """ cur: SortedList = points_x[x] ifnot cur: returnNone t = cur.bisect_left(y) if t >= len(cur): returnNone return cur[t]
defstart_light(points_x, points_y, points, p, d, i, t): x, y = p whileTrue: # 完全耗散 if i < 1: print(0, 0, 0) return if t <= 0: print(x, y, int(i)) # 根据方向查找最近的反射点 nx, ny = x, y if d == 0: nx = search_x_right(points_y, x, y) elif d == 1: ny = search_y_up(points_x, x, y) elif d == 2: nx = search_x_left(points_y, x, y) else: ny = search_y_down(points_x, x, y) # 不会遇到反射点，那么直接计算终点坐标即可 if nx isNoneor ny isNoneorabs(nx - x) > t orabs(ny - y) > t: if d == 0: x += t elif d == 1: y += t elif d == 2: x -= t else: y -= t print(x, y, int(i)) return mirror_type, a = points[nx][ny] t -= abs(nx - x) + abs(ny - y) i *= a x, y = nx, ny if mirror_type == 1: if d == 0: d = 1 elif d == 1: d = 0 elif d == 2: d = 3 elif d == 3: d = 2 else: if d == 0: d = 3 elif d == 1: d = 2 elif d == 2: d = 1 elif d == 3: d = 0
