7 368
Підписники
-224 години
-217 днів
-10930 день
Архів дописів
IBM-ISDL SLOTS AVAILABLE ✅
Contact : @MLCODER2
Note : Remote access available ☑️
def getKthMaximumORSum(arr, k):
from collections import Counter
n = len(arr)
count_map = Counter()
current_ors = Counter()
for x in arr:
new_ors = Counter()
for val, count in current_ors.items():
new_ors[val | x] += count
new_ors[x] += 1
for val, count in new_ors.items():
count_map[val] += count
current_ors = new_ors
sorted_sums = sorted(count_map.keys(), reverse=True)
for val in sorted_sums:
count = count_map[val]
if k <= count:
return val
k -= count
return -1
getKthMaximumORSum✅✅
def getClusterSizes(signature):
n = len(signature)
dsu = DSU(n)
prime_to_zone = {}
for i, sig in enumerate(signature):
temp = sig
d = 2
while d * d <= temp:
if temp % d == 0:
if d in prime_to_zone:
dsu.union(i, prime_to_zone[d])
else:
prime_to_zone[d] = i
while temp % d == 0:
temp //= d
d += 1
if temp > 1:
if temp in prime_to_zone:
dsu.union(i, prime_to_zone[temp])
else:
prime_to_zone[temp] = i
root_to_size = {}
for i in range(n):
root = dsu.find(i)
root_to_size[root] = root_to_size.get(root, 0) + 1
return [root_to_size[dsu.find(i)] for i in range(n)]
getClusterSizes✅
def findKthNextHigherDemandLevels(demandLevels, k):
n = len(demandLevels)
result = [-1] * n
sorted_unique_levels = sorted(list(set(demandLevels)))
rank_map = {val: i + 1 for i, val in enumerate(sorted_unique_levels)}
m = len(sorted_unique_levels)
tree = [0] * (4 * m + 1)
def update(node, start, end, idx, val):
if start == end:
tree[node] += val
return
mid = (start + end) // 2
if idx <= mid:
update(2 * node, start, mid, idx, val)
else:
update(2 * node + 1, mid + 1, end, idx, val)
tree[node] = tree[2 * node] + tree[2 * node + 1]
def query(node, start, end, l, r):
if r < start or end < l:
return 0
if l <= start and end <= r:
return tree[node]
mid = (start + end) // 2
return query(2 * node, start, mid, l, r) + query(2 * node + 1, mid + 1, end, l, r)
def find_kth(node, start, end, l, r, target_k):
if tree[node] < target_k:
return -1
if start == end:
return start
tree_max = [0] * (4 * n + 1)
def build(node, start, end):
if start == end:
tree_max[node] = demandLevels[start - 1]
return
mid = (start + end) // 2
build(2 * node, start, mid)
build(2 * node + 1, mid + 1, end)
tree_max[node] = max(tree_max[2 * node], tree_max[2 * node + 1])
build(1, 1, n)
def get_first_greater(node, start, end, l, r, val):
if r < start or end < l or tree_max[node] <= val:
return -1
if start == end:
return start
mid = (start + end) // 2
res = get_first_greater(2 * node, start, mid, l, r, val)
if res == -1:
res = get_first_greater(2 * node + 1, mid + 1, end, l, r, val)
return res
ans = []
for i in range(n):
current_val = demandLevels[i]
curr_idx = i + 2
target_idx = -1
for _ in range(k):
if curr_idx > n:
target_idx = -1
break
target_idx = get_first_greater(1, 1, n, curr_idx, n, current_val)
if target_idx == -1:
break
curr_idx = target_idx + 1
ans.append(target_idx)
return ans
findKthNextHigherDemandLevels✅
