2017-12-12 6 views
7

मैं संकेतों (लगातार mesures पेश करता है) की एक सूची के लिए मूल्य रखें:अजगर सूची ही बराबर यदि n पूर्ववर्तियों

signals = [0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0] 

मैं एक संकेत केवल पिछले n mesures के बराबर है, तो वैध पर विचार करें।

ईजी। अगर हम (n=2) प्रमाणीकरण के लिए केवल 2 मेसर्स पर विचार करते हैं, तो पहली बार सिग्नल 0 से 1 तक बदल जाते हैं, हम इसे अभी भी 0 पर मानते हैं, लेकिन अगली मेसुर, अगर यह फिर से 1 है तो हम मानते हैं कि यह अभी भी वैध है और इसे बनाना है। फिर हमें 2 की आवश्यकता होगी 0 के मेसर्स को इसे फिर से चालू करने के लिए, आदि ... यहां सिग्नल सरलीकरण के लिए 0 और 1 हैं लेकिन मेरे आवेदन में वे अन्य पूर्णांक हो सकते हैं।

वांछित उत्पादन:

# For n = 2: 
valid_s = [0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0] 

# For n = 3: 
valid_s = [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0] 

# For n = 4: 
valid_s = [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0] 

मैं इसे करने का एक pythonesque एक लाइनर रास्ते से देख रहा था लेकिन वांछित आउटपुट को खोजने के लिए प्रतीत नहीं कर सकते हैं।

S = signals 

# For n = 2 
[S[i] if S[i] == S[i-1] else S[i-2] for i, _ in enumerate(S)] 
# gives [0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0] 

# For n = 3 
[S[i] if S[i] == S[i-1] == S[i-2] else S[i-3] for i, _ in enumerate(S)] 
# gives [0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0] 

संपादित करें:: मैं पंक्तियों के साथ कुछ करने की कोशिश की मैं numpy के लिए खुला रहा हूँ अगर यह यह आसान बनाता है के रूप में यह पहले से ही आयातित है।

+0

क्या आपका वांछित आउटपुट n = 2 सही है? क्या आप अपने आउटपुट को केवल मापा मानों पर या पहले से ही "सही" पिछले मानों पर आधारित करते हैं? – voiDnyx

+0

हां, n = 2 के लिए मुझे 1 या 0 पर स्विच करने पर विचार करने के लिए लगातार दो या 0 की आवश्यकता है। यदि मेरे पास लगातार दो नहीं हैं, तो मैं पहले से ही पहले से मान्य मान रखता हूं। इसलिए एन = 2 के लिए वांछित आउटपुट। – Fredovsky

उत्तर

5

मुझे नहीं लगता कि यह एक लाइनर/सूची समझ बनाने का एक अच्छा तरीका है। जबकि आप सूची के एक टुकड़े के साथ all का उपयोग कर सकते हैं यह देखने के लिए कि क्या मान n मानों के समान है, मुझे यह निर्धारित करने का एक अच्छा तरीका नहीं दिख रहा है कि यह वैध मान्य मूल्य होना चाहिए या नहीं।

इसके बजाय, आप पाश के लिए एक अच्छा पुराने "कई लाइनों" इस्तेमाल कर सकते हैं:

signals = [0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0] 
n = 3 

last_valid = 0 
current = None 
repeated = 0 
res = [] 
for s in signals: 
    if s == current: 
     repeated += 1 
    else: 
     repeated = 1 
     current = s 
    if repeated >= n: 
     last_valid = s 
    res.append(last_valid) 

बाद में, res[0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0]


वैकल्पिक रूप से, एक सा कम, itertools.groupby उपयोग कर रहा है; परिणाम एक ही है:

last_valid = 0 
res = [] 
for k, g in itertools.groupby(signals): 
    m = len(list(g)) 
    if m >= n: 
     res.extend([last_valid] * (n-1) + [k] * (m-n+1)) 
     last_valid = k 
    else: 
     res.extend([last_valid] * m) 
+2

परिशिष्ट: और हमेशा के रूप में, यदि आप एक लाइन समाधान चाहते हैं, तो बस इसे एक समारोह बनाओ। ;-) –

+0

बिट कम और शायद सरल: https://ideone.com/vtjVUW –

+1

ओह, * बहुत * छोटा/सरल: https://ideone.com/cgEnpu –

2
signal = [0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0] 

def each(signal, n): 
    p = 0 
    ring = [ signal[0] ] * (n-1) 
    v = None 
    for x in signal: 
    if v is None or all(q == x for q in ring): 
     v = x 
    yield v 
    ring[p] = x 
    p = (p+1) % (n-1) 

list(each(signal, 2)) 
[0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0] 

लेकिन मैं इस पर फिर से विचार और लगता है कि एक शुद्ध पुनरावृत्ति (कम pythonic) दृष्टिकोण शायद अधिक सक्षम है। मेरा नया दृष्टिकोण पूरा करने के बाद अब मुझे लगता है कि यह वही विचार है जैसा कि @tobias_k पहले से ही उनके उत्तर में लागू किया गया है:

def each(signal, n): 
    current = signal[0] 
    next = None 
    for v in signal: 
    if v != current: 
     if v == next: 
     next_count += 1 
     else: 
     next_count = 1 
     next = v 
     if next_count >= n: 
     current = v 
    yield current 
+0

क्यों 'अंगूठी'? सूची की सिर्फ एक टुकड़ा क्यों नहीं? –

+0

स्लाइस बनाने का कारण शायद रिंगबफर का उपयोग करने से अधिक महंगा है। कार्यान्वयन पर निर्भर करता है जिसे मैं भरोसा नहीं करना चाहता हूं। – Alfe

+0

मान्य बिंदु, लेकिन समग्र जटिलता अभी भी 'ओ (लेन (एलएसटी) * एन)' –

संबंधित मुद्दे