def _grid_glyphs(self, glyphs):
x = self._x
y = self._y
K = self._K
leading = self._leading
FMX = self.font['__gridfont__'].character_index
colored_chars = list(chain.from_iterable(zip_longest([], text, fillvalue=self._palatte.get(token, (0, 0, 0, 1))) for token, text in xml_lexer.get_tokens(''.join(self._CHARS))))
# print(set(token for token, text in xml_lexer.get_tokens(''.join(self._CHARS))))
lines = list(_linebreak(colored_chars, self._charlength))
self._IJ = [0] + list(accumulate(len(l) for l, br in lines))
self.y_bottom = y + leading * len(lines)
y += leading
xd = x + 30
colored_text = {color: [] for color in self._palatte.values()}
for l, line in enumerate(lines):
for color, G in groupby(((FMX(character), xd + i*K, y + l*leading, color) for i, (color, character) in enumerate(line[0]) if character != '\n'),
key = lambda k: k[3]):
try:
colored_text[color].extend((g, h, k) for g, h, k, c in G)
except KeyError:
colored_text[color] = [(g, h, k) for g, h, k, c in G]
N = zip(accumulate(line[1] for line in lines), enumerate(lines))
numbers = chain.from_iterable(((FMX(character), x + i*K, y + l*leading) for i, character in enumerate(str(int(N)))) for N, (l, line) in N if line[1])
colored_text[(0.7, 0.7, 0.7, 1)] = list(numbers)
self._rows = len(lines)
self._colored_text = colored_text
#documentation
"""
def random(self):
types=["one","diff","sum","ratio"]
if(self.random_weight == None):
t= random.choice(types)
Channel1 = random.randint(0,self.nb_channels-1)
Channel2 = random.randint(0,self.nb_channels-1)
else:
acc = self.random_weight
weights = acc['RQE']['type']
cumdist = list(itertools.accumulate(weights))
x = random.random() * cumdist[-1]
t = types[bisect.bisect(cumdist, x)]
weights = acc['RQE']['channel']
cumdist = list(itertools.accumulate(weights))
x = random.random() * cumdist[-1]
Channel1 = bisect.bisect(cumdist, x)
x = random.random() * cumdist[-1]
Channel2 = bisect.bisect(cumdist, x)
option={ 'type' : 'RQE', 'RQE' : { 'type' : t,
'windows' : [
{ 'Channel' : Channel1},
{ 'Channel' : Channel2},
]
}
}
self.option = option
def test_accumulate(self):
res = accumulate([3, 4, 6, 2, 1, 9, 0, 7, 5, 8])
self.assertEqual([3, 7, 13, 15, 16, 25, 25, 32, 37, 45], list(res))
res = accumulate([3, 4, 6, 2, 1, 9, 0, 7, 5, 8], add)
self.assertEqual([3, 7, 13, 15, 16, 25, 25, 32, 37, 45], list(res))
res = accumulate([3, 4, 6, 2, 1, 9, 0, 7, 5, 8], max)
self.assertEqual([3, 4, 6, 6, 6, 9, 9, 9, 9, 9], list(res))
def solve(xs, n):
max_upto = list(it.accumulate(xs, max))
min_after = list(it.accumulate(reversed(xs), min))
min_after.reverse()
cnt = 1 + sum(1 for (left_max, right_min) in zip(max_upto, min_after[1:])
if left_max <= right_min)
return cnt
def running_stats(data_iterator):
''' Returns iterators for the running min, max, product, and sum.'''
# Replicate the input iterator as an iterator can be used only once.
i1, i2, i3, i4 = tee(data_iterator, 4)
rmin = accumulate(i1, min)
rmax = accumulate(i2, max)
rprd = accumulate(i3, mul)
rsum = accumulate(i4)
return rmin, rmax, rprd, rsum
def itaccumulate():
"""
accumulate(可迭代对象[, 函数])
attention: python3 avaliable!
"""
list(accumulate(range(10)))
# 叠加相加,默认是加,可以自己定义符号
# [0, 1, 3, 6, 10, 15, 21, 28, 36, 45]
list(accumulate(range(1,5),operator.mul))
def scored_plaintext(self, for_voter=None):
plaintext = Tagnostic(self.content).plaintext()
score_increments = [0] * (len(plaintext) + 1)
mark_increments = [0] * (len(plaintext) + 1)
for vote in self.vote_set.all():
score_increments[vote.start_index] += vote.value
score_increments[vote.end_index] -= vote.value
if for_voter and vote.voter == for_voter:
mark_increments[vote.start_index] += vote.value
mark_increments[vote.end_index] -= vote.value
return tuple(zip(plaintext,
itertools.accumulate(score_increments),
itertools.accumulate(mark_increments)))
def sim_game(homeo, homed, awayo, awayd, HFAmult):
import random
from itertools import accumulate
import bisect
from math import fsum
homeodds,awayodds = single_match_odds(homeo, homed, awayo, awayd, HFAmult)
hometotalodds = list(accumulate(homeodds))
awaytotalodds = list(accumulate(awayodds))
homerand = random.uniform(0,hometotalodds[-1])
awayrand = random.uniform(0,awaytotalodds[-1])
home_goals = bisect.bisect(hometotalodds, homerand)
away_goals = bisect.bisect(awaytotalodds, awayrand)
return home_goals, away_goals
def random(iterators, weights):
if weights is None:
weights = [1 for x in iterators]
if len(weights) != len(iterators):
raise ValueError("len of iterators and weights must be same")
cumdist = list(itertools.accumulate(weights))
while iterators:
it_pos = bisect.bisect(cumdist, rnd.random() * cumdist[-1])
try:
yield next(iterators[it_pos])
except StopIteration:
del iterators[it_pos]
del weights[it_pos]
cumdist = list(itertools.accumulate(weights))
def __init__(self, lang):
total = sum(lang_cnt_dict[i] + 1 for i in lang)
#avg = total / len(lang)
weights = (int(total / (lang_cnt_dict[i] + 1)) for i in lang)
self.pop = list(lang)
self.weights = list(itertools.accumulate(weights))
def find_maximum_subarray(A):
min_sum = max_sum = 0
for running_sum in itertools.accumulate(A):
min_sum = min(min_sum, running_sum)
max_sum = max(max_sum, running_sum - min_sum)
return max_sum
def reduce_cumulative(links, outmost_links, index): ret = [attrdict(arity = 1)] if len(links) == 1: ret[0].call = lambda t: list(itertools.accumulate(iterable(t), lambda x, y: dyadic_link(links[0], (x, y)))) else: ret[0].call = lambda z: [reduce_simple(t, links[0]) for t in split_rolling(iterable(z), links[1].call())] return ret
def test_camera_stream_frames_trunc_left():
camera = mock.Mock()
encoder = mock.Mock()
camera._encoders = {1: encoder}
stream = PiCameraCircularIO(camera, size=10)
frames = []
for data, frame in generate_frames('hkffkffhkff'):
encoder.frame = frame
if frame.complete:
frames.append(frame)
stream.write(data)
del frames[:3]
# As we've gotten rid of the start of the stream we need to re-calc the
# video and split sizes in the comparison meta-data
sizes = accumulate(f.frame_size for f in frames)
frames = [
PiVideoFrame(
f.index,
f.frame_type,
f.frame_size,
size,
size,
f.timestamp,
f.complete
)
for f, size in zip(frames, sizes)
]
assert stream.getvalue() == b'fkkffhkkff'
assert list(stream.frames) == frames
assert list(reversed(stream.frames)) == frames[::-1]
def scanl(func=op.add, acc=0, col=[]):
'''
Fold a collection from the left using a binary function
and an accumulator into a list of values: [x, f(x), f(f(x), ...]
'''
with_acc = itools.chain([acc], col)
return itools.accumulate(with_acc, func)
def main():
# cycle iterator can be used to cycle over a collection
seq1 = ["Joe", "John", "Mike"]
cycle1 = itertools.cycle(seq1)
print(next(cycle1))
print(next(cycle1))
print(next(cycle1))
print(next(cycle1))
# use count to create a simple counter
count1 = itertools.count(100, 10)
print(next(count1))
print(next(count1))
print(next(count1))
# accumulate creates an iterator that accumulates values
vals = [10,20,30,40,50,40,30]
acc = itertools.accumulate(vals, max)
print(list(acc))
# use chain to connect sequences together
x = itertools.chain("ABCD", "1234")
print(list(x))
# dropwhile and takewhile will return values until
# a certain condition is met that stops them
print(list(itertools.dropwhile(testFunction, vals)))
print(list(itertools.takewhile(testFunction, vals)))
def compute_actual_burndown(cards):
dd = create_done_dict(cards)
number_days = days_in_month(next(iter(dd.values()))[0][0])
done_hist = create_done_histogram(dd)
dates = sorted([dateparser.parse(cards[ci]['history'][0][1]) for ci in cards if cards[ci]['history'][0][0]!='someday'])
newitems = [0]*number_days
for di in dates:
newitems[di.day-1] += 1
# cumulative frequency of new items
newitems_cumfreq = [si for si in accumulate(newitems)]
# cumulative freq of completed items
done_cumfreq = [si for si in accumulate(done_hist)]
# burndown is the difference
actual_bdown = [newitems_cumfreq[ii]-val for ii,val in enumerate(done_cumfreq)]
#
return actual_bdown
def move(self, direction):
if direction == self.OPPOSITE[self.direction]:
raise ValueError
new_head = PythonHead(self._head.coords + direction)
if new_head.coords.x < 0 or new_head.coords.x >= len(self.world):
raise Death
if new_head.coords.y < 0 or new_head.coords.y >= len(self.world):
raise Death
new_head_cell = self.world[new_head.coords.x][new_head.coords.y]
if isinstance(new_head_cell, PythonPart):
raise Death
if isinstance(new_head_cell, Food):
self.energy += new_head_cell.energy
new_head_cell.contents = new_head
last_part_offset = list(accumulate(
part.direction for part in self._body))[-1]
last_part_coords = self._head.coords + last_part_offset
self.world[last_part_coords.x][last_part_coords.y].contents = None
new_part = PythonPart(self.OPPOSITE[self.direction])
self.world[self._head.coords.x][
self._head.coords.y].contents = new_part
self.direction = direction
self._body = [new_part] + self._body[:-1]
self._head = new_head
def fracKnapsack(vl, wt, W, n):
r = list(sorted(zip(vl,wt), key=lambda x:x[0]/x[1],reverse=True))
vl , wt = [i[0] for i in r],[i[1] for i in r]
acc=list(accumulate(wt))
k = bisect(acc,W)
return 0 if k == 0 else sum(vl[:k])+(W-acc[k-1])*(vl[k])/(wt[k]) if k!=n else sum(vl[:k])
def find_longest_subarray_less_equal_k(A, k):
# Builds the prefix sum according to A.
prefix_sum = list(itertools.accumulate(A))
# Early returns if the sum of A is smaller than or equal to k.
if prefix_sum[-1] <= k:
return len(A)
# Builds min_prefix_sum.
min_prefix_sum = list(
reversed(
functools.reduce(lambda s, v: s + [min(v, s[-1])],
reversed(prefix_sum[:-1]), [prefix_sum[-1]])))
a = b = max_length = 0
while a < len(A) and b < len(A):
min_curr_sum = (min_prefix_sum[b] - prefix_sum[a - 1]
if a > 0 else min_prefix_sum[b])
if min_curr_sum <= k:
curr_length = b - a + 1
if curr_length > max_length:
max_length = curr_length
b += 1
else: # min_curr_sum > k.
a += 1
return max_length
def __init__(self, rects):
"""
:type rects: List[List[int]]
"""
self.rects = rects
self.sizes = list(map(lambda x: (x[2]-x[0]+1) * (x[3]-x[1]+1), rects))
self.weights = list(accumulate(self.sizes))
def get_next_char_decay(char): # Nearly six times slower!
try:
followers, accumulated_counts = bi_acc_cache_np[char]
except KeyError:
followers, counts = zip(*bigram_counts[char].items())
accumulated_counts = np.fromiter(accumulate(counts), dtype=np.int32)
bi_acc_cache_np[char] = followers, accumulated_counts
loc = np.int32(accumulated_counts[-1] * random())
follower = bisect.bisect(accumulated_counts, loc)
current_count = accumulated_counts[follower]
if follower:
current_count -= accumulated_counts[follower-1]
if current_count > 1:
if current_count < REDUCE_COUNT_BY_nTH:
decrement = 1
else:
decrement = current_count//REDUCE_COUNT_BY_nTH
accumulated_counts[follower:] -= decrement
# if len(accumulated_counts) == 5 and char == 'ణ్ని':
# print("{}) {:5d} < {:5d} picks {:2d} removed {:4d}//{} = {:3d} from {} {}".format(
# len(accumulated_counts), loc, accumulated_counts[-1], follower,
# current_count, REDUCE_COUNT_BY_nTH, decrement, accumulated_counts, char))
return followers[follower]
def impl(curr_axiom, curr_n):
if curr_n < 1:
return curr_axiom
newaxiom = []
# Replace each symbol in the axiom
for S in curr_axiom:
if S in s_to_rules:
# Todo: These steps could be moved out of the loop!
# Sort by probability
current_rules = sorted(s_to_rules[S], key=lambda x: x[0])
# The total probability for all the rules for the given S
prob_total = sum((R for R, Abc in current_rules))
# Construct a list of weights, ordered and scaled by total
weights = [R/prob_total for R, Abc in current_rules]
weights_acc = list(itertools.accumulate(weights))
p = rng()
selected_rule = None
last_w = 0
for i,w in zip(range(0, len(weights_acc)), weights_acc):
if p >= last_w and p <= w:
selected_rule = current_rules[i]
break
else:
last_w = w
_, Abc = selected_rule
newaxiom.extend(Abc)
else:
newaxiom.append(S)
continue
return impl(newaxiom, curr_n - 1)
def triangle_numbers():
"""
>>> import itertools
>>> [i for i in itertools.islice(triangle_numbers(), 5)]
[1, 3, 6, 10, 15]
"""
return itertools.accumulate(itertools.count(1))
def flatOffset(idxs, shape, base=1): idxs = chain(idxs, repeat(0, len(shape) - len(idxs))) idxs = [idx.indices(s)[0] if isinstance(idx, slice) else idx % s for idx, s in zip(idxs, shape)] shape = chain((base,), reversed(shape)) shapes = accumulate(shape, operator.mul) return sum( idx * s for idx, s in zip(reversed(idxs), shapes) )
def transform_labels_with_representation(labels):
representation = find_representation(labels)
labels_count = labels.shape[0]
new_labels = np.zeros((labels_count, 1))
labels_sums = np.array(list(map(lambda x: list(itertools.accumulate(x)), labels))).T
starting_from = 0
for class_size, class_k in representation:
sums = labels_sums[starting_from + class_size - 1]
if starting_from != 0:
sums -= labels_sums[starting_from - 1]
#print(sums)
extra = [[(class_k - sums[label_id])*1.0/class_k for val_id in range(class_k)] for label_id in range(labels_count)]
extra = np.array(extra)
#print(new_labels.shape)
#print(labels.shape)
new_labels = np.append(new_labels, labels[:, starting_from: (starting_from + class_size)], axis=1)
new_labels = np.append(new_labels, extra, axis=1)
starting_from += class_size
K = count_max_number_of_ones_in_matrix(new_labels)
for label_id in range(labels_count):
for char_id in range(len(new_labels[label_id])):
new_labels[label_id, char_id]*=1.0/K
print('Representation : ', representation)
return new_labels[:, 1:], representation
def solve(xs, d):
xs.sort()
ms, fs = list(zip(*xs))
n = len(ms)
fsacc = list(it.accumulate(it.chain((0,), fs)))
out = []
for i, money in enumerate(ms):
k = bisect.bisect_right(ms, money + d - 1)
# print_stderr('----------')
# print_stderr('i =', i)
# print_stderr('k =', k)
# print_stderr('d =', d)
# print_stderr('ms=', ms)
# print_stderr('ms[i] =', ms[i])
# print_stderr('ms[k-1] =', ms[k-1])
# print_stderr('fs[i] =', fs[i])
# print_stderr('fs[k-1] =', fs[k-1])
# out.append(sum(fs[i:k]))
out.append(fsacc[k] - fsacc[i])
if k == n:
break
return max(out)
def instructors_over_time(self, request, format=None):
"""Cumulative number of instructor appearances on workshops over
time."""
badges = Badge.objects.instructor_badges()
qs = Person.objects.filter(badges__in=badges)
filter = InstructorsOverTimeFilter(request.GET, queryset=qs)
qs = filter.qs.annotate(
date=Min('award__awarded'),
count=Value(1, output_field=IntegerField())
).order_by('date')
serializer = InstructorsOverTimeSerializer(qs, many=True)
# run a cumulative generator over the data
data = accumulate(serializer.data, self._add_counts)
# drop data for the same days by showing the last record for
# particular date
data = self._only_latest_date(data)
data = self.listify(data, request, format)
return Response(data)
def chord_notes(root = 'C', ch_name = 'M', mode = 'ionian'):
"""
returns a list of notes that compose a given chord
@param root (str) the root note
@param ch_name (str) the modifier (M for major, m for minor...)
@param mode (str) the mode
>>> chord_notes()
['C', 'E', 'G']
>>> chord_notes(root='F')
['F', 'A', 'C']
>>> chord_notes(root='G', ch_name='7')
['G', 'B', 'D', 'F']
"""
assert root in Notes and ch_name in Chords and mode in Modes
intervals_cumsum = [0] + list(accumulate(Modes[mode]))
return [
Notes[i] for i in
[
(Notes.index(root) + intervals_cumsum[deg-1] + ChordsModifiers[mod]) % len(Notes)
for deg, mod in Chords[ch_name]
]
]
def bwtPartialMatch(pattern, d, sarr):
# divide the pattern into d+1 parts
patternLen = len(pattern)
divLen = int(patternLen/(d+1))
extra = patternLen % (d+1)
divLen = [divLen]*(d+1-extra) + [divLen+1]*extra
divIndex = list(itertools.accumulate([0]+divLen))
# find a pattern that has exact match
smallPatterns = [pattern[divIndex[pi]:divIndex[pi+1]] for pi in range(d+1)]
smallMatchIndexes = [bwtMatch(p) for p in smallPatterns]
# extend the non empty patterns
nonEmptyPatternMatchIndexes = [pi for pi in range(d+1) if len(smallMatchIndexes[pi]) > 0]
allPartialMatchIndexes = set()
for pi in range(d+1):
if len(smallMatchIndexes[pi]) > 0:
# if there are exact matches
exactMatchIndexes = smallMatchIndexes[pi]
extendedStartIndexes = [sarr[mi] - divIndex[pi] \
for mi in exactMatchIndexes\
if sarr[mi] - divIndex[pi] >= 0]
partialMatchIndexes = [si for si in extendedStartIndexes \
if hammingDistance(genome[si:si+patternLen], pattern) <= d]
for i in partialMatchIndexes:
allPartialMatchIndexes.add(i)
return allPartialMatchIndexes
def encode(self, values):
self.validate_value(values)
raw_head_chunks = []
tail_chunks = []
for value, encoder in zip(values, self.encoders):
if getattr(encoder, 'is_dynamic', False):
raw_head_chunks.append(None)
tail_chunks.append(encoder(value))
else:
raw_head_chunks.append(encoder(value))
tail_chunks.append(b'')
head_length = sum(
32 if item is None else len(item)
for item in raw_head_chunks
)
tail_offsets = (0,) + tuple(accumulate(map(len, tail_chunks[:-1])))
head_chunks = tuple(
encode_uint_256(head_length + offset) if chunk is None else chunk
for chunk, offset in zip(raw_head_chunks, tail_offsets)
)
encoded_value = b''.join(head_chunks + tuple(tail_chunks))
return encoded_value
for item in items:
w, v = item
if w == w0:
w0_list.append(v)
if w == w0 + 1:
w1_list.append(v)
if w == w0 + 2:
w2_list.append(v)
if w == w0 + 3:
w3_list.append(v)
w0_list = sorted(w0_list, reverse=True)
w1_list = sorted(w1_list, reverse=True)
w2_list = sorted(w2_list, reverse=True)
w3_list = sorted(w3_list, reverse=True)
w0_accum = tuple(accumulate(w0_list))
w1_accum = tuple(accumulate(w1_list))
w2_accum = tuple(accumulate(w2_list))
w3_accum = tuple(accumulate(w3_list))
ans = 0
for i in range(len(w0_list) + 1):
for j in range(len(w1_list) + 1):
for k in range(len(w2_list) + 1):
for m in range(len(w3_list) + 1):
if w0 * i + (w0 + 1) * j + (w0 + 2) * k + (w0 + 3) * m > W:
continue
else:
tmp = 0
if i > 0:
tmp += w0_accum[i - 1]
def is_prime(n):
if n == 1: return 0
for k in range(2, int(math.sqrt(n)) + 1):
if n % k == 0:
return 0
return 1
Q = int(input())
L = [0] * Q
R = [0] * Q
for j in range(Q):
L[j], R[j] = [int(i) for i in input().split()]
min_L = min(L)
max_R = max(R)
li = []
for i in range(min_L, max_R + 1, 1):
if i % 2 == 1:
li.append(is_prime(i) * is_prime((i + 1) // 2))
else:
li.append(0)
ans = [0]
ans += list(accumulate(li))
for i, j in zip(L, R):
print(ans[j - min_L + 1] - ans[i - min_L])
def select_mutation(self):
# Implementation from https://docs.python.org/3/library/random.html -- Ctrl+F "weights"
choices, weights = zip(*self.mutations.items())
cumdist = list(accumulate(weights))
x = random.random() * cumdist[-1]
self.selected_mutation = choices[bisect(cumdist, x)]
def visualizeTransactions(resultDir, transactionFilePath):
if transactionFilePath:
# read transactions file
with open(transactionFilePath) as transactions_file:
transactions = json.loads(transactions_file.read())
# prepare transaction data
data_by_day = groupBy(filter(transactionIsBtc, transactions["data"]),
transactionToIsoDate)
spent_data_by_day_last_month = groupBy(
filter(
lambda t: transactionIsEurSpent(t) and transactionIsLastMonth(
t),
transactions["data"],
),
transactionToYearMonthDay,
)
spent_data_by_year_month = groupBy(
filter(transactionIsEurSpent, transactions["data"]),
transactionToYearMonth)
spent_data_by_user = groupBy(
filter(transactionIsEurSpent, transactions["data"]),
transactionToUserEmail)
wallet_balance_btc_by_day_keys = list(data_by_day.keys())
wallet_balance_btc_by_day_keys.sort()
wallet_balance_btc_by_day_keys_datetimes = list(
map(
lambda d: np.datetime64(isoDateToDatetime(d)),
wallet_balance_btc_by_day_keys,
))
wallet_balance_btc_by_day_values = list(
accumulate([
sum(map(transactionToBtc, data_by_day[k]))
for k in wallet_balance_btc_by_day_keys
]))
eur_by_day_last_month = {
k: -1 * sum(map(transactionToEur, v))
for k, v in spent_data_by_day_last_month.items()
}
eur_by_year_month = {
k: -1 * sum(map(transactionToEur, v))
for k, v in spent_data_by_year_month.items()
}
eur_by_user = {
k: -1 * sum(map(transactionToEur, v))
for k, v in spent_data_by_user.items()
}
# draw diagrams
plt.rcdefaults()
drawBarChart(
"Transactions per day over the last month",
"EUR",
eur_by_day_last_month.keys(),
eur_by_day_last_month.values(),
)
plt.savefig(os.path.join(resultDir, "transactions_per_day.png"),
bbox_inches="tight")
drawBarChart(
"Transactions per month",
"EUR",
eur_by_year_month.keys(),
eur_by_year_month.values(),
)
plt.savefig(os.path.join(resultDir, "transactions_per_month.png"),
bbox_inches="tight")
drawEurPerUser("Transactions per user", "EUR", eur_by_user.keys(),
eur_by_user.values())
plt.savefig(os.path.join(resultDir, "transactions_per_user.png"),
bbox_inches="tight")
drawTimeSeries(
"BTC wallet per day in last month",
"BTC",
wallet_balance_btc_by_day_keys_datetimes,
wallet_balance_btc_by_day_values,
)
plt.savefig(os.path.join(resultDir, "wallet_balance_per_day.png"),
bbox_inches="tight")
# 3, 7, 11
list1.append(next(t))
print(list1)
list2 = [1, 8, 2, 4]
t1 = itertools.cycle(list2)
print(next(t1))
print(next(t1))
print(next(t1))
print(next(t1))
print(next(t1))
print(next(t1))
# add all previous values to current value
t2 = itertools.accumulate(list2)
print(list(t2))
# loops thru the list and pins to the largest number
t2 = itertools.accumulate(list2, max)
print(list(t2))
t3 = itertools.chain("Red", "Hat")
print(list(t3))
numbers = [0, 1, 2, 4, 5, 7]
t4 = itertools.dropwhile(functionA, numbers)
print(list(t4))
t5 = itertools.takewhile(functionA, numbers)
print(list(t5))
def PrefixSum(arr):
return list(accumulate(arr))
def pref_sum(a):
return list(accumulate(a))
def accumulate(self, iterable, func=operator.add):
return itertools.accumulate(iterable, func)
def get_result(self):
'''
O(N) かけて、区間の加算結果を取得する
'''
from itertools import accumulate
return list(accumulate(self.ls[:-1]))
def _handle_cumulative(self, entity_metrics: List) -> List[Dict[str, Any]]:
for metrics in entity_metrics:
metrics.update(data=list(accumulate(metrics["data"])))
return entity_metrics
from itertools import accumulate
INF = float('inf')
N, *A = map(int, open(0).read().split())
l = list(accumulate(A, min))
r = list(accumulate(A[::-1], min))[::-1]
result = INF
# 凸 タイプの門松列の場合
for i in range(1, N - 1):
a = l[i - 1]
b = A[i]
c = r[i + 1]
if a <= b and c <= b:
result = min(result, a + b + c)
# 凹 タイプの門松列の場合
for i in range(1, N - 1):
a = l[i - 1]
b = A[i]
c = r[i + 1]
if b <= a and b <= c:
result = min(result, a + b + c)
if result == INF:
print(-1)
else:
print(result)
import itertools import collections N = int(input()) A = list(map(int, input().split())) acum = list(itertools.accumulate(A, initial=0)) c = collections.Counter(acum) print(sum(n * (n - 1) // 2 for n in c.values())) # nC2
def calc_peptide_prefix_masses(peptide):
return list(it.accumulate(peptide.masses, operator.add, initial=0))
def plackett_luce(rankings,
tolerance=1e-9,
check_assumption=True,
normalize=True,
verbose=False):
'''This algorithm returns the MLE of the Plackett-Luce ranking parameters
over a given set of rankings. It requires that the set of players is unable
to be split into two disjoint sets where nobody from set A has beaten anyone from
set B. If this assumption fails, the algorithm will diverge. If the
assumption is checked and fails, the algorithm will short-circuit and
return None.
Input is a list of dictionaries, where each dictionary corresponds to an
individual ranking and contains the player : finish for that ranking.
Output is a dictionary containing player : plackett_luce_parameter keys
and values.
'''
players = set(key for ranking in rankings for key in ranking.keys())
rankings = [
sorted(ranking.keys(), key=ranking.get) for ranking in rankings
]
if verbose:
print('Using native Python implementation of Plackett-Luce.')
print('{:,} unique players found.'.format(len(players)))
print('{:,} rankings found.'.format(len(rankings)))
if check_assumption:
edges = [(source, dest) for ranking in rankings
for source, dest in combinations(ranking, 2)]
scc_count = len(set(scc(edges).values()))
if verbose:
if scc_count == 1:
print(
'No disjoint sets found. Algorithm convergence conditions are met.'
)
else:
print('{:,} disjoint sets found. Algorithm will diverge.'.
format(scc_count))
if scc_count != 1:
return None
ws = Counter(name for ranking in rankings for name in ranking[:-1])
gammas = {player: 1.0 / len(players) for player in players}
gdiff = float('inf')
iteration = 0
start = time.perf_counter()
while gdiff > tolerance:
_gammas = gammas
gamma_sums = [
list(
accumulate(1 / s for s in reversed(
list(
accumulate(gammas[finisher]
for finisher in reversed(ranking))))))
for ranking in rankings
]
gammas = {
player: ws[player] /
sum(gamma_sum[min(ranking.index(player),
len(ranking) - 2)]
for ranking, gamma_sum in zip(rankings, gamma_sums)
if player in ranking)
for player in players
}
if normalize:
gammas = {
player: gamma / sum(gammas.values())
for player, gamma in gammas.items()
}
pgdiff = gdiff
gdiff = sqrt(
sum((gamma - _gammas[player])**2
for player, gamma in gammas.items()))
iteration += 1
if verbose:
now = time.perf_counter()
print("%d %.2f seconds L2=%.2e" % (iteration, now - start, gdiff))
if gdiff > pgdiff:
print("Gamma difference increased, %.4e %.4e" %
(gdiff, pgdiff))
start = now
return gammas
from heapq import heapify, heappushpop
from itertools import accumulate
x, y, z = map(int, input().split())
persons = [list(map(int, input().split())) for _ in range(x + y + z)]
persons.sort(key=lambda abc: abc[0] - abc[1])
ans_g = sum(x[0] for x in persons[-x:])
ans_s = sum(x[1] for x in persons[:y])
ans_c = sum(x[2] for x in persons[y:-x])
gold_pq = [a - c for a, b, c in persons[-x:]]
silver_pq = [b - c for a, b, c in persons[:y]]
heapify(gold_pq)
heapify(silver_pq)
ans_f = [0]
for a, b, c in persons[y:-x]:
np = b - c
rp = heappushpop(silver_pq, np)
ans_f.append(np - rp)
ans_b = [0]
for a, b, c in persons[-x - 1:y - 1:-1]:
np = a - c
rp = heappushpop(gold_pq, np)
ans_b.append(np - rp)
ans_f = list(accumulate(ans_f))
ans_b = list(accumulate(ans_b))
print(ans_g + ans_s + ans_c + max(sum(z) for z in zip(ans_f, reversed(ans_b))))
def getheightprofile():
dataset = get_dataset(tenant_handler.tenant())
query = request.json
if not isinstance(
query, dict
) or not "projection" in query or not "coordinates" in query or not "distances" in query or not "samples" in query:
return jsonify({"error": "Bad query"})
if not isinstance(query["coordinates"],
list) or len(query["coordinates"]) < 2:
return jsonify(
{"error": "Insufficient number of coordinates specified"})
if not isinstance(query["distances"], list) or len(
query["distances"]) != len(query["coordinates"]) - 1:
return jsonify({"error": "Invalid distances specified"})
try:
epsg = int(
re.match(r'epsg:(\d+)', query["projection"],
re.IGNORECASE).group(1))
except:
return jsonify({"error": "Invalid projection specified"})
try:
numSamples = int(query["samples"])
except:
return jsonify({"error": "Invalid sample count specified"})
inputSpatialRef = osr.SpatialReference()
if inputSpatialRef.ImportFromEPSG(epsg) != 0:
return jsonify({"error": "Failed to parse projection"})
crsTransform = osr.CoordinateTransformation(inputSpatialRef,
dataset["spatialRef"])
gtrans = dataset["geoTransform"]
elevations = []
x = 0
i = 0
p1 = query["coordinates"][i]
p2 = query["coordinates"][i + 1]
dr = (p2[0] - p1[0], p2[1] - p1[1])
cumDistances = list(accumulate(query["distances"]))
cumDistances.insert(0, 0)
totDistance = sum(query["distances"])
for s in range(0, numSamples):
while i + 2 < len(cumDistances) and x > cumDistances[i + 1]:
i += 1
p1 = query["coordinates"][i]
p2 = query["coordinates"][i + 1]
dr = (p2[0] - p1[0], p2[1] - p1[1])
mu = (x - cumDistances[i]) / (cumDistances[i + 1] - cumDistances[i])
pRaster = crsTransform.TransformPoint(p1[0] + mu * dr[0],
p1[1] + mu * dr[1])
# Geographic coordinates to pixel coordinates
col = (-gtrans[0] * gtrans[5] + gtrans[2] * gtrans[3] -
gtrans[2] * pRaster[1] + gtrans[5] * pRaster[0]) / (
gtrans[1] * gtrans[5] - gtrans[2] * gtrans[4])
row = (-gtrans[0] * gtrans[4] + gtrans[1] * gtrans[3] -
gtrans[1] * pRaster[1] + gtrans[4] * pRaster[0]) / (
gtrans[2] * gtrans[4] - gtrans[1] * gtrans[5])
data = dataset["band"].ReadRaster(math.floor(col), math.floor(row), 2,
2, 2, 2, gdal.GDT_Float64)
if not data or len(data) != 32:
elevations.append(0.)
else:
values = struct.unpack('d' * 4, data)
kRow = row - math.floor(row)
kCol = col - math.floor(col)
value = (values[0] * (1. - kCol) + values[1] * kCol) * (
1. - kRow) + (values[2] *
(1. - kCol) + values[3] * kCol) * (kRow)
elevations.append(value * dataset["unitsToMeters"])
x += totDistance / (numSamples - 1)
return jsonify({"elevations": elevations})
from itertools import accumulate
import numpy as np
with open('A-large.in') as f:
cases = int(f.readline())
for i in range(cases):
ringers = 0
max_shyness, audience = f.readline().split()
audience = [int(shyness) for shyness in audience]
cumulative = np.array(list(accumulate(audience)))
threshold = np.arange(int(max_shyness) + 1)
diff = threshold - cumulative
if np.max(diff) >= 0:
ringers = np.max(diff) + 1
print("Case #{0}: {1}".format(i + 1, ringers))
#! python3
"""The sequence of triangle numbers is generated by adding the natural numbers.
What is the value of the first triangle
number to have over five hundred divisors?"""
from itertools import accumulate
from itertools import count
from math import sqrt
import sys
from os.path import dirname
sys.path.insert(0, dirname(dirname(__file__)))
from utils import sixn
def factors_n(n):
fac = 1
for i in sixn(int(sqrt(n)) + 1):
x = 1
while not n % i:
x += 1
n //= i
fac *= x
if n != 1:
fac *= 2
return fac
for i in accumulate(count()):
if factors_n(i) > 500:
print(i)
break
def __init__(self, w):
self.w = list(itertools.accumulate(w))
# -*- coding: utf-8 -*-
from itertools import accumulate
def inpl():
return tuple(map(int, input().split()))
N = int(input())
S = [0 for _ in range(10**5 + 1)]
P = [[0] * 3 for _ in range(10**5 + 1)]
A = []
for _ in range(N):
R, H = inpl()
P[R][H - 1] += 1
S[R] += 1
A.append([R, H])
S = list(accumulate(S))
for R, H in A:
w = S[R - 1] + P[R][H % 3]
d = P[R][H - 1] - 1
l = N - w - d - 1
print("{} {} {}".format(w, l, d))
def find_break(pos, ns):
cumsum = list(accumulate(xmas[pos:]))
return cumsum.index(weakness) if weakness in cumsum else None
def MakeBinNcum(self):
self.binned.update(
ncum=list(it.accumulate(reversed(self.binned['n']))))
self.binned.update(
ncum_event=list(it.accumulate(reversed(self.binned['n_event']))))
def _compute_evas(self, ts: int) -> None:
# Update durable counters and compute per-class and total hit rates
total_hits: int = 0
total_events: int = 0
class_hit_rates: Dict[Hashable, array[float]] = {}
for clas, info in self._class_infos.items():
info.durable_hit_counters.update(info.hit_counters,
self._ewma_factor)
info.durable_eviction_counters.update(info.eviction_counters,
self._ewma_factor)
info.hit_counters.reset()
info.eviction_counters.reset()
class_hit_rates[clas] = reversed_array(
'd',
map(
lambda x: lenient_div(x[0], (x[0] + x[1])),
itertools.accumulate(
zip_longest_reversed_arrays(
info.durable_hit_counters.bin_data,
info.durable_eviction_counters.bin_data,
),
lambda a, b: (a[0] + b[0], a[1] + b[
1]), # functools.partial(map, operator.plus)
),
))
total_hits += info.durable_hit_counters.total
total_events += info.durable_hit_counters.total + info.durable_eviction_counters.total
total_hit_rate: float = lenient_div(
total_hits, total_events
) # TODO: might be zero because EWMA leads to events disappearing
# per_access_gain is the expected hit rate for a single item in the cache (i.e. a line or a byte).
per_access_gain = total_hit_rate / self._count_of_items_in_cache()
time_interval = ts - self._last_eva_computation_ts
if time_interval == 0:
# If the last eva computation happened in the same second, pretend it was one second ago
time_interval = 1
per_age_bin_width_avg_accesses = self._age_bin_width * total_events / time_interval # TODO: this is a very rough "estimate"
# average gain of an item in the cache during a duration of age_bin_width
per_age_bin_width_avg_gain = per_access_gain * per_age_bin_width_avg_accesses
# Calculate per-class EVAs
print()
pprint({
'time_interval': time_interval,
'ts': ts,
'self._last_eva_computation_ts': self._last_eva_computation_ts,
'self._age_bin_width': self._age_bin_width,
'per_age_bin_width_avg_accesses':
per_age_bin_width_avg_accesses,
'per_age_bin_width_avg_gain': per_age_bin_width_avg_gain,
'total_events': total_events,
'total_hit_rate': total_hit_rate,
})
for clas, info in self._class_infos.items():
max_counters_length = max(
len(info.durable_hit_counters.bin_data),
len(info.durable_eviction_counters.bin_data),
)
last_bin_events = (
array_get(info.durable_hit_counters.bin_data,
max_counters_length - 1) +
array_get(info.durable_eviction_counters.bin_data,
max_counters_length - 1))
# TODO: use centre of the bin for calculations.
info.evas.set_bin_data(
reversed_array(
'd',
map(
# (cumulative_hits - per_age_bin_width_avg_gain * cumulative_lifetimes) / (cumulative_hits + cumulative_evictions)
lambda x: lenient_div(
(x[1] - per_age_bin_width_avg_gain * x[0]),
(x[1] + x[2])),
# input x: (cumulative_lifetimes, cumulative_hits, cumulative_evictions) in reverse order of bins.
# cumulative_lifetimes is the sum of all future lifetimes. divide this by the number of future
# events to get the expected lifetime (in units of age bin width).
# cumulative_hits is the number of all future hits.
# cumulative_evictions is the number of all future evictions.
map(
# interpolate: centre of the age bin
lambda x: (x[0] + x[5] / 2, x[1] + x[3] / 2, x[
2] + x[4] / 2),
itertools.accumulate(
zip_longest_reversed_arrays(
array(
'q',
itertools.repeat(
0, max_counters_length)),
array(
'q',
itertools.repeat(
0, max_counters_length)),
array(
'q',
itertools.repeat(
0, max_counters_length)),
info.durable_hit_counters.bin_data,
info.durable_eviction_counters.
bin_data,
# accumulate yields the first input item (the last item here) as is, so
# setting it to the correct value is necessary:
array('q',
[0] * (max_counters_length - 1) +
[last_bin_events]),
),
lambda acc, inp: (
acc[0] + acc[
5
], # last cumulative lifetime counter + increase
acc[1] + acc[
3
], # increase by previous hit counter value
acc[2] + acc[
4
], # increase by previous eviction counter value
inp[
3
], # next hit counter value (carried forward from input)
inp[
4
], # next eviction counter value (carried forward from input)
(acc[1] + acc[3] + inp[3]) +
(acc[2] + acc[4] + inp[4]
), # next increase of
# the cumulative life time counter: the next value of cumulative hits + next
# value of cumulative evictions
),
),
),
)))
pprint({
'clas':
clas,
'per_age_bin_width_avg_gain':
per_age_bin_width_avg_gain,
'hits':
info.durable_hit_counters.bin_data,
'evictions':
info.durable_eviction_counters.bin_data,
'max_counters_length':
max_counters_length,
'last_bin_events':
last_bin_events,
'accumulation':
list(
itertools.accumulate(
zip_longest_reversed_arrays(
array('q',
itertools.repeat(0,
max_counters_length)),
array('q',
itertools.repeat(0,
max_counters_length)),
array('q',
itertools.repeat(0,
max_counters_length)),
info.durable_hit_counters.bin_data,
info.durable_eviction_counters.bin_data,
# accumulate yields the first input item (the last item here) as is, so
# setting it to the correct value is necessary:
array('q', [0] * (max_counters_length - 1) +
[last_bin_events]),
),
lambda acc, inp: (
acc[0] + acc[
5
], # last cumulative lifetime counter + increase
acc[1] + acc[
3
], # increase by previous hit counter value
acc[2] + acc[
4
], # increase by previous eviction counter value
inp[
3
], # next hit counter value (carried forward from input)
inp[
4
], # next eviction counter value (carried forward from input)
(acc[1] + acc[3] + inp[3]) +
(acc[2] + acc[4] + inp[4]), # next increase of
# the cumulative life time counter: the next value of cumulative hits + next
# value of cumulative evictions
),
)),
'evas':
info.evas.bin_data,
})
# Apply 'reused' bias
for clas, info in self._class_infos.items():
reused_class = _ReusedClassifier.to_reused(clas)
bias: float
if (reused_class in self._class_infos
and len(class_hit_rates[reused_class]) > 0
and class_hit_rates[reused_class][0] != 1.0):
bias = (self._class_infos[reused_class].evas[0] /
(1.0 - class_hit_rates[reused_class][0]))
else:
continue
for bin_edge, class_hit_rate in zip(info.evas,
class_hit_rates[clas]):
info.evas[bin_edge] += (class_hit_rate -
total_hit_rate) * bias
pprint({
'clas': clas,
'evas (bias applied)': info.evas.bin_data,
})
# Reset counters
self._accesses_since_eva_computation = 0
self._last_eva_computation_ts = ts
from itertools import accumulate
n = int(input())
a = list(map(int, input().rstrip().split()))
b = list(accumulate(a))
q = int(input())
for i in range(q):
l, r = list(map(int, input().split()))
if l == r:
print(a[l])
else:
print(b[r] - b[l] + a[l])
m.agent.play_round()
m.record_metrics()
x = range(1, rounds + 1)
optimal_regret = [0] * rounds
pylab.plot(x, optimal_regret, label='optimal', linestyle='--')
for m in agents:
y = m.pseudo_regret
pylab.plot(x, y, label=m.agent.algorithm)
pylab.legend(loc='upper left')
pylab.xlabel('t')
pylab.ylabel('katumus')
save(f'regret_{rounds}')
pylab.show()
optimal_reward = list(accumulate([rewards.best_action().expected] * rounds))
pylab.plot(x, optimal_reward, label='optimal', linestyle='--')
for m in agents:
y = m.reward
pylab.plot(x, y, label=m.agent.algorithm)
pylab.xlabel('t')
pylab.ylabel('tuotto')
pylab.legend(loc='upper left')
save(f'reward_{rounds}')
pylab.show()
def getStreaks(order, today):
# At first I get all the times the habit was repeated from the order.checkedList of the Order.object.
date_array = list(order.checkedList.all())
# "list_of_days_since_first_repeat" saves the dates with all the dates from the very first one ever to today.
list_of_days_since_first_repeat = []
# "list_of_repeat_days" saves the dates which were checked
list_of_repeat_days = []
# "week_habit" appends all weeks which passed since the first time anything was checked.
week_habit = []
# the first week is initalized today.
week_habit_date = today
# Below we get all the Repeats ever created.
repeats = Repeats.objects.all()
# first_time_stamp is first set to "None" in order not to confuse the system in case there are no repeats-objects to it yet, because
# it hasen't been checked yet.
first_time_stamp = None
# Earliest throws an exception if there are no Repeats. This is why below there is the try-except block.
try:
first_time_stamp = repeats.earliest('dateAsString')
except:
pass
# That is done below in order to avoid none in the queryset
if first_time_stamp:
# first_repeats is really just the first_time_stamp just parsed to be a date and not a string.
first_repeats = parse_date(first_time_stamp.dateAsString)
# If today is acutally todays's date then lastRepats stands for yesterday. We do this so that the current streak
# is not automatically 0 if you haven't pressed it today
last_repeats = today - timedelta(days=1)
# time_stamp_deltas gives us a timedelta-object from yesterday to the first time anything was ever checked.
time_stamp_deltas = last_repeats - first_repeats
# In this the list_of_days_since_first_repeat is produced.
for k in range(time_stamp_deltas.days + 1):
time_stamp_day = first_repeats + timedelta(days=k)
list_of_days_since_first_repeat.append(time_stamp_day)
# I start today and walk backwards. Here I get all the weeks. Regardless if they were checked or not.
while week_habit_date > first_repeats:
# 7 days are subtracted from today
week_habit_date -= timedelta(days=7)
# This week is not included, in order to be a streak, even if this week it wasn't checked yet.
week_habit.append(week_habit_date)
# Weekdays are received in reverse order.
week_habit.reverse()
# date_array is an array which has all the days which were checked
for repeat in date_array:
repeated_days = parse_date(repeat.dateAsString)
list_of_repeat_days.append(repeated_days)
# The data type "Set" gets rid of all duplicates.
checked_days_array = set(list_of_repeat_days)
# inCheckedDays is there in order not to need exact matches. The timedelta establishes the week in the future.
def inCheckedDays(x, checked_days):
# x is whatever day of the week today is.
for i in checked_days:
# The line below determines whether i is contained in the week starting at x.
# That is determined by wheater i is on or after x and before the week after x.
if x <= i < x + timedelta(days=7):
return True
return False
def tryingWeekly(a, x):
count_current_before, longest_streak_before = a
count_current_after = count_current_before + 1
# x in this case is the same weekday of whatever weekday is "today". x will eventually take all the values of
# each of the current weekday in each week from today to the date of the first repeat except for this week.
if inCheckedDays(x, checked_days_array):
return (count_current_after, count_current_after
if count_current_after > longest_streak_before else
longest_streak_before)
else:
return (0, longest_streak_before)
def tryingDaily(a, x):
# a is a tuple
count_current_before, longest_streak_before = a
# if x (one date in checked_days_array) is in the checked days the current streak will be updated by 1, else it will be set to 0
count_current_after = count_current_before + 1 if x in checked_days_array else 0
return (count_current_after, count_current_after
if count_current_after > longest_streak_before else
longest_streak_before)
# Initial=(0,0) stands for the tuple a that is being initialized with 0,0
result = list(
accumulate(list_of_days_since_first_repeat,
tryingDaily,
initial=(0, 0))) if order.interval == "Daily" else list(
accumulate(week_habit, tryingWeekly, initial=(0, 0)))
# [-1] is for the last tuple. The second [] stands for either the currentStreak [0] or the longestStreak[1].
# I used accumulate insted of functools reduce to help debug the result and to grasp the intermediate steps.
order.longestStreak = result[-1][1]
order.streak = result[-1][0]
order.save()
def idfn(sections_data):
'''Returns the name of the test according to the parameters'''
num_l = len(sections_data.splitlines())
return 'sections_{}'.format(num_l)
import itertools
import operator
# list of mandatory sections
data = '''version: 1
lattice: asd
states: asd
excitations: asd
sensitizer_decay: asd
activator_decay: asd'''
# combinations of sections. At least 1 is missing
list_data = list(itertools.accumulate(data.splitlines(keepends=True)[:-1], operator.concat))
@pytest.mark.parametrize('sections_data', list_data, ids=idfn)
def test_sections_config(sections_data):
with pytest.raises(SettingsFileError) as excinfo:
with temp_config_filename(sections_data) as filename:
settings.load(filename)
assert excinfo.match(r"Those sections must be present")
assert excinfo.match(r"Sections that are needed but not present in the file")
assert excinfo.type == SettingsFileError
# should get a warning for an extra unrecognized section
def test_extra_sections_warning_config():
data = data_all_mandatory_ok+'''extra_unknown_section: dsa'''
with pytest.warns(SettingsExtraValueWarning) as warnings:
with temp_config_filename(data) as filename:
settings.load(filename)
print()
print('Using num2 with Take While Function > return value if True')
fltr_t = itertools.takewhile(lt_2, num2)
for i in fltr_t:
print(i)
# After hiting the first value verifying the condition, it discard the rest of
# the iterables, regardless of its value, or the condition.
print()
#######################
# Accumulate Function #
#######################
# Keeps a running total (Sum by default) of the iterables
print('Accumulates Function')
print('default == Sum')
acc_default = itertools.accumulate(num2)
for i in acc_default:
print(i)
print()
print('Specific == multiply')
num3 = [1, 2, 3, 2, 1, 0]
print("using num3 = [1, 2, 3, 2, 1, 0]")
acc_mul = itertools.accumulate(num3, operator.mul)
for i in acc_mul:
print(i)
# Works if the first iterable isn't 0,
# or everything in the iterable will be == 0
print()
#############
# Group Val #
from itertools import accumulate
N, M, K = map(int, input().split())
a = [0] + list(accumulate(int(i) for i in input().split()))
b = [0] + list(accumulate(int(i) for i in input().split()))
cnt = 0
best0 = M
for i in range(N + 1):
ai = a[i]
for j in range(best0, -1, -1):
bj = b[j]
if ai + bj <= K:
cnt = max(cnt, i + j)
best0 = j
break
print(cnt)
def iterating(initial_array):
return list(accumulate(initial_array))
