मेरे पास कई सुन्न सरणियाँ हैं और मैं कुछ ऐसा करने वाले नए सरणियाँ बनाना चाहता हूँ जो एक XOR की तरह है ... लेकिन काफी नहीं।

मेरा इनपुट दो सरणियों, सरणी 1 और सरणी 2 है। मेरा आउटपुट array1 का एक संशोधित (या नया सरणी, मुझे वास्तव में परवाह नहीं है) संस्करण है।

निम्नलिखित कार्य करके संशोधन तत्ववार है:

1.) यदि दिए गए सूचकांक के लिए किसी भी सरणी में 0 है, तो सूचकांक अपरिवर्तित रहता है। 2.) यदि array1 और array2 गैर-शून्य हैं, तो संशोधित सरणी को array1 के इंडेक्स का मान दिया जाता है, जिसे array2 के इंडेक्स से घटाकर न्यूनतम शून्य कर दिया जाता है।

उदाहरण:

array1:  [0, 3, 8, 0]
array2:  [1, 1, 1, 1]
output:  [0, 2, 7, 0]


array1:  [1, 1, 1, 1]
array2:  [0, 3, 8, 0]
output:  [1, 0, 0, 1]

array1:  [10, 10, 10, 10]
array2:  [8, 12, 8, 12]
output:  [2, 0, 2, 0]

मैं इसे कहने में सक्षम होना चाहता हूं, एक numpy.copyto कथन, लेकिन मुझे नहीं पता कि कैसे। धन्यवाद।

संपादित करें:

यह सिर्फ मुझे मारा। क्या मैं कर सकता हूँ:

new_array = np.zeros(size_of_array1)
numpy.copyto(new_array, array1-array2, where=array1>array2)

संपादित करें २: चूंकि मुझे बहुत जल्दी कई उत्तर मिल गए हैं, इसलिए मैं एक-दूसरे के खिलाफ अलग-अलग उत्तरों को देखने जा रहा हूं कि वे कैसे करते हैं। कुछ ही मिनटों में परिणाम के साथ वापस आएं।

ठीक है, परिणाम इसमें हैं:

यादृच्छिक ints 0 से 5, आकार = १०,०००, १० छोरों की सरणी

1.) my np.copyto विधि का उपयोग कर

2.) क्लिप का उपयोग करना

3.)अधिकतम . का उपयोग करना

0.000768184661865
0.000391960144043
0.000403165817261

Kasramvd ने नीचे कुछ उपयोगी समय भी दिए हैं

3
Travis Black 24 जून 2018, 19:58

3 जवाब

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

आप एक साधारण घटाव का उपयोग कर सकते हैं और परिणाम को min के रूप में शून्य से क्लिप कर सकते हैं:

(arr1 - arr2).clip(min=0)

डेमो:

In [43]: arr1 = np.array([0,3,8,0]); arr2 = np.array([1,1,1,1])

In [44]: (arr1 - arr2).clip(min=0)
Out[44]: array([0, 2, 7, 0])

बड़े सरणियों पर यह maximum दृष्टिकोण से भी तेज़ है:

In [51]: arr1 = np.arange(10000); arr2 = np.arange(10000)

In [52]:  %timeit np.maximum(0, arr1 - arr2)
22.3 µs ± 1.77 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

In [53]: %timeit (arr1 - arr2).clip(min=0)
20.9 µs ± 167 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

In [54]: arr1 = np.arange(100000); arr2 = np.arange(100000)

In [55]:  %timeit np.maximum(0, arr1 - arr2)
671 µs ± 5.69 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

In [56]: %timeit (arr1 - arr2).clip(min=0)
648 µs ± 4.43 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

ध्यान दें कि यदि arr2 के लिए ऋणात्मक मान होना संभव है, तो आपको अपेक्षित परिणाम प्राप्त करने के लिए arr2 पर abs फ़ंक्शन का उपयोग करने पर विचार करना चाहिए:

(arr1 - abs(arr2)).clip(min=0)
4
Kasravnd 24 जून 2018, 20:34

आप पहले केवल सरणियों को घटा सकते हैं और फिर का उपयोग कर सकते हैं boolean array indexing घटाए गए परिणाम पर 0 असाइन करने के लिए जहां नकारात्मक मान हैं:

# subtract
In [43]: subtracted = arr1 - arr2

# get a boolean mask by checking for < 0
# index into the array and assign 0
In [44]: subtracted[subtracted < 0] = 0

In [45]: subtracted
Out[45]: array([0, 2, 7, 0])

ओपी द्वारा निर्दिष्ट अन्य इनपुट के लिए इसे लागू करना:

In [46]: arr1 = np.array([1, 1, 1, 1])
    ...: arr2 = np.array([0, 3, 8, 0])

In [47]: subtracted = arr1 - arr2
In [48]: subtracted[subtracted < 0] = 0

In [49]: subtracted
Out[49]: array([1, 0, 0, 1])

और तीसरे इनपुट सरणियों के लिए:

In [50]: arr1 = np.array([10, 10, 10, 10])
    ...: arr2 = np.array([8, 12, 8, 12])

In [51]: subtracted = arr1 - arr2
In [52]: subtracted[subtracted < 0] = 0

In [53]: subtracted
Out[53]: array([2, 0, 2, 0])
0
kmario23 24 जून 2018, 23:13
In [73]: np.maximum(0,np.array([0,3,8,0])-np.array([1,1,1,1]))
Out[73]: array([0, 2, 7, 0])

यह स्पष्ट रूप से संबोधित नहीं करता है

यदि दिए गए सूचकांक के लिए किसी भी सरणी में 0 है, तो सूचकांक को अपरिवर्तित छोड़ दिया जाता है।

लेकिन परिणाम सभी उदाहरणों के लिए मेल खाते हैं:

In [74]: np.maximum(0,np.array([1,1,1,1])-np.array([0,3,8,0]))
Out[74]: array([1, 0, 0, 1])
In [75]: np.maximum(0,np.array([10,10,10,10])-np.array([8,12,8,12]))
Out[75]: array([2, 0, 2, 0])
4
hpaulj 24 जून 2018, 20:10