在python中向上计数然后向下计算一个范围

Question

I am trying to program a standard snake draft, where team A pick, team B, team C, team C, team B, team A, ad nauseum.

If pick number 13 (or pick number x) just happened how can I figure which team picks next for n number of teams.

I have something like:

def slot(n,x):
    direction = 'down' if (int(x/n) & 1) else 'up'
    spot = (x % n) + 1
    slot = spot if direction == 'up' else ((n+1) - spot)
    return slot

I have feeling there is a simpler, more pythonic what than this solution. Anyone care to take a hack at it?

So I played around a little more. I am looking for the return of a single value, rather than the best way to count over a looped list. The most literal answer might be:

def slot(n, x): # 0.15757 sec for 100,000x 
    number_range = range(1, n+1) + range(n,0, -1)
    index = x % (n*2)
    return number_range[index]

This creates a list [1,2,3,4,4,3,2,1], figures out the index (eg 13 % (4*2) = 5), and then returns the index value from the list (eg 4). The longer the list, the slower the function.

We can use some logic to cut the list making in half. If we are counting up (ie (int(x/n) & 1) returns False), we get the obvious index value (x % n), else we subtract that value from n+1:

def slot(n, x): # 0.11982 sec for 100,000x 
    number_range = range(1, n+1) + range(n,0, -1)
    index = ((n-1) - (x % n)) if (int(x/n) & 1) else (x % n)
    return number_range[index]

Still avoiding a list altogether is fastest:

def slot(n, x): # 0.07275 sec for 100,000x
    spot = (x % n) + 1
    slot = ((n+1) - spot) if (int(x/n) & 1) else spot
    return slot

And if I hold the list as variable rather than spawning one:

number_list = [1,2,3,4,5,6,7,8,9,10,11,12,12,11,10,9,8,7,6,5,4,3,2,1]
def slot(n, x): # 0.03638 sec for 100,000x
    return number_list[x % (n*2)]

Answer 1

Why not use itertools cycle function:

from itertools import cycle
li = range(1, n+1) + range(n, 0, -1) # e.g. [1, 2, 3, 4, 4, 3, 2, 1]
it = cycle(li)

[next(it) for _ in xrange(10)] # [1, 2, 3, 4, 4, 3, 2, 1, 1, 2]

Note: previously I had answered how to run up and down, as follows:

it = cycle(range(1, n+1) + range(n, 0, -1)) #e.g. [1, 2, 3, 4, 3, 2, 1, 2, 3, ...]

Answer 2

Here's a generator that will fulfill what you want.

def draft(n):
    while True:
        for i in xrange(1,n+1):
            yield i
        for i in xrange(n,0,-1):
            yield i

>>> d = draft(3)
>>> [d.next() for _ in xrange(12)]
[1, 2, 3, 3, 2, 1, 1, 2, 3, 3, 2, 1]

Answer 3

from itertools import chain, cycle

def cycle_up_and_down(first, last):
    up = xrange(first, last+1, 1)
    down = xrange(last, first-1, -1)
    return cycle(chain(up, down))

turns = cycle_up_and_down(1, 4)
print [next(turns) for n in xrange(10)] # [1, 2, 3, 4, 4, 3, 2, 1, 1, 2]

Answer 4

Here is a list of numbers that counts up, then down:

>>> [ -abs(5-i)+5 for i in range(0,10) ]
[0, 1, 2, 3, 4, 5, 4, 3, 2, 1]

Written out:

count_up_to = 5
for i in range( 0, count_up_to*2 ):
  the_number_you_care_about = -abs(count_up_to-i) + count_up_to
  # do stuff with the_number_you_care_about

Easier to read:

>>> list( range(0,5) ) + list( range( 5, 0, -1 ) )
[0, 1, 2, 3, 4, 5, 4, 3, 2, 1]

Written out:

count_up_to = 5
for i in list( range(0,5) ) + list( range(5, 0, -1) ):
  # i is the number you care about

Another way:

from itertools import chain
for i in chain( range(0,5), range(5,0,-1) ):
  # i is the number you care about