गिनती और फिर पाइथन

Question

में एक रेंज को गिनती है, मैं एक मानक सांप ड्राफ्ट प्रोग्राम करने की कोशिश कर रहा हूं, जहां टीम ए पिक, टीम बी, टीम सी, टीम सी, टीम बी, टीम ए, विज्ञापन मतली।

यदि नंबर 13 (या संख्या संख्या चुनें) चुनें तो बस यह पता लगाया जा सकता है कि कौन सी टीम टीमों की संख्या के लिए आगे बढ़ती है।

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 

मैं महसूस कर रही है वहाँ एक सरल, अधिक pythonic क्या इस समाधान से:

मैं की तरह कुछ है। किसी को भी हैक लेने की परवाह है?

तो मैंने थोड़ा और अधिक खेला। मैं एक लूप सूची पर गिनने के सर्वोत्तम तरीके के बजाय, एक मूल्य की वापसी की तलाश में हूं। सबसे शाब्दिक जवाब हो सकता है: (उदाहरण के लिए 13%

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] 

यह एक सूची [1,2,3,4,4,3,2,1] बनाता है, सूचकांक का पता लगा लेता (4 * 2) = 5), और फिर सूची से सूचकांक मान देता है (उदाहरण के लिए 4)। सूची जितनी लंबी होगी, फंक्शन धीमा होगा।

हम आधे में सूची बनाने में कटौती करने के लिए कुछ तर्क का उपयोग कर सकते हैं। हम तक की गिनती कर रहे हैं (यानी (int(x/n) & 1) झूठी देता है), हम स्पष्ट सूचकांक मूल्य (एक्स% एन) मिलता है, वरना हम 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] 

फिर भी कुल मिलाकर एक सूची से परहेज है सबसे तेजी से:

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 

और अगर मैं नहीं बल्कि एक को उत्पन्न करने की तुलना में चर के रूप में सूची पकड़:

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

itertools का प्रयोग क्यों न cycle समारोह:

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] 

नोट: पहले मैं, ऊपर और नीचे चलाने के लिए कैसे जवाब था इस प्रकार है:

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

Answer 2

यहाँ एक जनरेटर आप क्या चाहते पूरा करेगा कि है।

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]