如果循环x次，计算列表项的通过次数的公式是什么

Question

Given

    list =['a','b','c']

How to get number of times an item gets accessed when cycling the list x times. For example:

    # if we cycled list 4 times, output would be
    output = [('a',2), ('b',1), ('c',1)]

    # if we cycled list 7 times, output would be
    output = [('a',3), ('b',2), ('c',2)]

Is there a formula for this, or a loop is necessary?

Answer 1

You could calculate this partially, but a loop is needed at some point for this approach. Use floor division to find how many complete passes are made, then increment the rest by 1 (starting from the left) for the remainder - incomplete passes:

data = ['a', 'b', 'c']
cycles = 7
complete_passes, remainder = divmod(cycles, len(data))
passes = {i: complete_passes for i in data}
for key in data[:remainder]:
    passes[key] += 1

Note on divmod :

divmod(x, y)

...returns...

(x//y, x%y)
# floor division, modulus

Answer 2

This might not be the best approach but you might still find it useful. The idea is to find have the extended list and then use Counter to get the occurrence frequency

from collections import Counter

n = 7
listt = ['a','b','c']

a = n%len(listt) 
b = int(n/len(listt))

listt = listt*b + listt[0:a]
result = [(i, j) for i,j in Counter(listt).items()]
print (result)
# [('a', 3), ('b', 2), ('c', 2)]

Answer 3

You can simply divide the length of the list by the number of loops, and add 1 for the elements whose index is less than the remainder:

def nb_accesses(sequence, loops):
    length = len(sequence)
    out = [(value, loops // length + (index < loops % length))
            for index, value in enumerate(sequence)]
    return out

sequence = ['a', 'b', 'c']

print(nb_accesses(sequence, loops=0))
# [('a', 0), ('b', 0), ('c', 0)]

print(nb_accesses(sequence, loops=3))
# [('a', 1), ('b', 1), ('c', 1)]

print(nb_accesses(sequence, loops=5))
# [('a', 2), ('b', 2), ('c', 1)]

index < loops % length evaluates to 0 (False) or 1 (True).

Answer 4

The number of times we visit the k -th item in a list with n items, and v visits is ⌈(vk)/n⌉, which is equivalent to ⌊(v-k+n-1)/n⌋. After all we make v visits, so that means each item has at least ⌊v/n-1⌋ visits. The last "round" distributes the remaining v - ⌊v/n-1⌋ , and the first v - ⌊v/n-1⌋ items "retrieve" a visit.

We can generate such list in linear time with:

def visit_count(data, v):
    n = len(data)
    return [(x, (v-i+n-1)//n) for i, x in enumerate(data)]

For example:

>>> visit_count('abc', 7)
[('a', 3), ('b', 2), ('c', 2)]
>>> visit_count('abc', 8)
[('a', 3), ('b', 3), ('c', 2)]
>>> visit_count('abc', 9)
[('a', 3), ('b', 3), ('c', 3)]
>>> visit_count('abc', 10)
[('a', 4), ('b', 3), ('c', 3)]

Since this runs in the length of the list, and not in the number of visits, it means that we can solve this problem for reasonable lists, and a huge number of visits. For example:

>>> visit_count('abcde', 1_234_567_890_123_456)
[('a', 246913578024692), ('b', 246913578024691), ('c', 246913578024691), ('d', 246913578024691), ('e', 246913578024691)]

Doing the bookkeeping for 1'234'567'890'123'456 visits individually would result in the function taking ages to obtain the result. But since the number of elements (here 5) is limited, it takes only a few microseconds.

Answer 5

Given

import itertools as it
import collections as ct


lst = list("abc")
n = 7

Code

iterable = (it.islice(it.cycle(lst),  n)
[(k, v) for k, v in ct.Counter(iterable).items()]
# [('a', 3), ('b', 2), ('c', 2)]