मैं आकार एम के फ्लोट्स की एक सूची जेनरेट करना चाहता हूं, जहां सूची में प्रत्येक आइटम अन्य कार्यवाही आइटम यानी अवरोही क्रम से बड़ा है। और सूची का योग 1 होना चाहिए और उसी एम परिमाण के लिए मैं एक से अधिक सूची उत्पन्न कर सकता हूं जो दिए गए बाधाओं का पालन करता है।

मैं निम्नलिखित रूप में एक समीकरण के बारे में सोच रहा हूँ:

Xi+1 = compute([Xi,Xi-1...X0], M, Random)

लेकिन मैं इस समारोह की सीमा का पता लगाने में सक्षम नहीं हूँ। पहले ही, आपका बहुत धन्यवाद।

1
adnanmuttaleb 2 अक्टूबर 2018, 22:22

3 जवाब

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

ठीक है, तो चलिए ० से १० तक १० यादृच्छिक संख्याएँ चुनते हैं, और उन्हें क्रमबद्ध करते हैं। फिर योग की गणना करें और इस योग से विभाजित प्रत्येक तत्व के साथ एक नई सूची का पुनर्निर्माण करें:

import random

# create a non-normalized ascending list of numbers
lst = sorted(random.uniform(0,10) for _ in range(10))
# compute the sum
temp_sum = sum(lst)
# now divide each member by the sum to normalize the list
lst = [i/temp_sum for i in lst]

print(lst,sum(lst))

एक आउटपुट हो सकता है:

[0.0340212528820301, 0.05665995400192079, 0.07733861892990018,
 0.07752841352220373, 0.08556431469182045, 0.11628857362899164,      
0.11706017358757258, 0.12523809404875455, 0.14272942597136748, 
0.16757117873543856] 1.0

फ्लोटिंग पॉइंट अशुद्धि के कारण योग ठीक 1 नहीं हो सकता है, लेकिन बहुत करीब होगा।

4
Jean-François Fabre 2 अक्टूबर 2018, 19:28

यदि आप गणितीय रूप से अनुमानित एक-लाइनर चाहते हैं, तो यह है ... (आपको यह दिखाने के लिए लूप कि यह कैसा दिखता है)

for length in range(1, 10):
    array = [2*x/(length * (length + 1)) for x in range(length,0,-1)]
    print(sum(array), array)

यह निम्नलिखित आउटपुट उत्पन्न करता है। ध्यान दें कि यह अन्य सभी एल्गोरिदम की तरह फ़्लोटिंग पॉइंट राउंडिंग त्रुटियों के लिए अतिसंवेदनशील है। कुछ बेहतर और कुछ बदतर एल्गोरिदम हैं, लेकिन किसी बिंदु पर, उन सभी में कुछ त्रुटि होगी।

Sum: 1.0 Array: [1.0]
Sum: 1.0 Array: [0.6666666666666666, 0.3333333333333333]
Sum: 0.9999999999999999 Array: [0.5, 0.3333333333333333, 0.16666666666666666]
Sum: 0.9999999999999999 Array: [0.4, 0.3, 0.2, 0.1]
Sum: 1.0 Array: [0.3333333333333333, 0.26666666666666666, 0.2, 0.13333333333333333, 0.06666666666666667]
Sum: 0.9999999999999998 Array: [0.2857142857142857, 0.23809523809523808, 0.19047619047619047, 0.14285714285714285, 0.09523809523809523, 0.047619047619047616]
Sum: 1.0 Array: [0.25, 0.21428571428571427, 0.17857142857142858, 0.14285714285714285, 0.10714285714285714, 0.07142857142857142, 0.03571428571428571]
Sum: 1.0 Array: [0.2222222222222222, 0.19444444444444445, 0.16666666666666666, 0.1388888888888889, 0.1111111111111111, 0.08333333333333333, 0.05555555555555555, 0.027777777777777776]
Sum: 0.9999999999999999 Array: [0.2, 0.17777777777777778, 0.15555555555555556, 0.13333333333333333, 0.1111111111111111, 0.08888888888888889, 0.06666666666666667, 0.044444444444444446, 0.022222222222222223]
1
David Culbreth 2 अक्टूबर 2018, 21:42

यदि आप कुछ ऐसा चाहते हैं जो गणितीय रूप से अनुमानित हो ...

def makeDescendingUnitArray(length: int):
    if (not isinstance(length, int)) or (length < 1):
        raise ValueError("Array Length must be an int with a value of at least 1")
    if length == 1:
        return [1]
    else:
        constant = 1
        output = list()
        for x in range(length - 2):
            constant /= 2
            output.append(constant)
        return output + [2*constant/3, constant/3]

for arrayLength in range(1, 10):
    array = makeDescendingUnitArray(arrayLength)
    print(array)

निम्नलिखित सरणियों का उत्पादन करता है ...

[1]
[0.6666666666666666, 0.3333333333333333]
[0.5, 0.3333333333333333, 0.16666666666666666]
[0.5, 0.25, 0.16666666666666666, 0.08333333333333333]
[0.5, 0.25, 0.125, 0.08333333333333333, 0.041666666666666664]
[0.5, 0.25, 0.125, 0.0625, 0.041666666666666664, 0.020833333333333332]
[0.5, 0.25, 0.125, 0.0625, 0.03125, 0.020833333333333332, 0.010416666666666666]
[0.5, 0.25, 0.125, 0.0625, 0.03125, 0.015625, 0.010416666666666666, 0.005208333333333333]
[0.5, 0.25, 0.125, 0.0625, 0.03125, 0.015625, 0.0078125, 0.005208333333333333, 0.0026041666666666665]
2
David Culbreth 2 अक्टूबर 2018, 19:38