मेरे पास पूर्णांकों की एक सूची है, उदा। i=[1,7,3,1,5] जिसे मैं पहली बार लंबाई के संबंधित बाइनरी अभ्यावेदन की सूची में बदल देता हूं L, उदा। b=["001","111","011","001","101"] L=3 के साथ।

अब मैं यह गणना करना चाहता हूं कि द्विआधारी प्रतिनिधित्व में कितने L पदों में एक 1 और साथ ही एक शून्य 0 है। मेरे उदाहरण में परिणाम return=2 होगा क्योंकि इन प्रविष्टियों के लिए हमेशा तीसरी (अंतिम) स्थिति में 1 होता है। मुझे किसी भी टिप्पणी के लिए खुशी होगी। मुझे लगता है, आदर्श रूप से मुझे एक ही समय में कई Xor ऑपरेशन करने चाहिए। हालांकि, मुझे यकीन नहीं है कि मैं इसे कुशलतापूर्वक कैसे कर सकता हूं।

संपादित करें: कई उत्तरों के लिए धन्यवाद !! मुझे जांचना है कि कौन सा सबसे तेज़ है।

0
HighwayJohn 12 नवम्बर 2020, 12:17

5 जवाब

सबसे बढ़िया उत्तर

एक अवलोकन यह है कि यदि आप सभी संख्याओं का AND और सभी संख्याओं का OR भी लेते हैं, तो उन दो परिणामों के XOR में 1 होगा जहां शर्त पूरी होती है।

इसलिए:

from functools import reduce
from operator import and_, or_

def count_mixed_bits(lst):
    xor = reduce(and_, lst) ^ reduce(or_, lst)
    return bin(xor).count("1")


count_mixed_bits([1,7,3,1,5])  # 2
3
trincot 12 नवम्बर 2020, 12:47

आप इस कार्य के लिए पायथन बिटवाइज ऑपरेटरों का उपयोग कर सकते हैं।

def find(aList, nn):
    return sum( 
      filter( 
        lambda bb: bb > 0 ,
        (
          ( 1 <= (sum( (aa & 1<<kk) > 0 for aa in aList)) < len(aList) )
          for kk in range(nn)
        )
      )
    )

>>> find([1,7,3,1,5],3)
2
>>> find([],3)
0
>>> find([7],3)
0
>>> find([7,1],3)
2
>>> find([7,1,7],3)
2
0
napuzba 12 नवम्बर 2020, 15:33

सबसे पहले आपके प्रश्न को numpy के साथ टैग किया गया है लेकिन आपकी सरणी एक numpy array नहीं है। यहाँ एक समाधान है जो numpy का उपयोग करता है:

import numpy as np

def has_zeroes_and_ones_at_index(arr, index_from_right):
    shifted_arr = np.right_shift(arr, index_from_right)
    has_one_at_index = shifted_arr % 2 == 1
    return(True in has_one_at_index and False in has_one_at_index)

arr = np.array([1, 7, 3, 1, 5])
res= has_zeroes_and_ones_at_index(arr, 1)
print(res)

क्योंकि संख्याओं को बाइनरी में संग्रहीत किया जाता है, हम संख्याओं के सभी बिट्स को दाईं ओर ले जाने के लिए बिट शिफ्टिंग का उपयोग कर सकते हैं और फिर अंतिम बिट को देख सकते हैं। हमें उन्हें पहले बाइनरी प्रारूप में नहीं डालना है। 5 (101) एक से दाएं शिफ्ट -> 2 (010)

फिर हम यह देखने के लिए एक मुखौटा बनाते हैं कि कौन से नंबरों में अंतिम बिट में एक है और जब मुखौटा में कम से कम एक सत्य तत्व और एक गलत तत्व होता है तो सत्य वापस आ जाता है।

1
Adrian Tompkins 13 नवम्बर 2020, 12:47

यहाँ एक समाधान है, मुझे संदेह है कि यह बहुत कुशल नहीं है, लेकिन इसे समझना आसान है।

मैं अंकों पर लूप करता हूं और अद्वितीय सेट ढूंढता हूं, फिर मैं दो की निर्धारित लंबाई वाली प्रविष्टियों की संख्या गिनता हूं:

# create a binary list of 3 elements from input list of integers
i=[1,7,3,1,5]
b=['{0:03b}'.format(x) for x in i]

# loop over the digit position (1,2,3)
cnt=[]
for pos in range(3):
    cnt.append(len(set([c[pos] for c in b])))

# cnt now contains a list of either 2(=both 1 and 0 present) or 1 (unique)
# so now we count the number of entries with "2"
result=cnt.count(2)
print (result)

उत्तर:

2
1
Adrian Tompkins 12 नवम्बर 2020, 14:28

एक numpy.binary_repr तरीका है जो लंबाई को स्वीकार करता है। दुर्भाग्य से, यह सरणियों को संभाल नहीं सकता है। लेकिन आप np.unravel_index की कार्यक्षमता लागू कर सकते हैं बजाय:

def check(arr, lenght):
    positions = np.array(np.unravel_index(i, (2,)*lenght))
    return positions, np.sum(np.sum(positions, axis=1) != len(arr))

>>> positions, output = check(i, 3)
>>> print(positions)
>>> print(output)
[[0 1 0 0 1]
 [0 1 1 0 0]
 [1 1 1 1 1]]
2
1
Adrian Tompkins 12 नवम्बर 2020, 14:27