मुझे लगा कि यह पहली बार में एक संयोग था इसलिए मैंने इसे आज़माने के लिए एक परीक्षण लिखा और यह सच है, मैंने इसे 1 मिलियन बार चलाया और हर बार सेट वापस आया और क्रमबद्ध किया गया। यह केवल तब होता है जब आप 0-9 से पूर्णांकों का उपयोग करते हैं जैसे ही एक पूर्णांक> 9 डाला जाता है, उसके बाद डाला गया कोई भी पूर्णांक सॉर्ट नहीं किया जाएगा। ऐसा क्यों है? इसके अलावा तैरने के लिए यह एक तरह का है लेकिन हर समय सही नहीं है, इतना अजीब मैंने सोचा कि वे पूरी तरह से अनियंत्रित थे। हर बार 0-9 को क्यों क्रमबद्ध किया जाता है, इस पर कोई सलाह बहुत सराहना की जाएगी, मुझे पहले तो इस पर विश्वास नहीं था, इसलिए यहां मैंने जो कोड इस्तेमाल किया है, आप इसे आसानी से स्वयं चला सकते हैं और देख सकते हैं कि यह सच है।

import random

def check_set():
    constructing = True
    s = set()
    while constructing:
        x = random.randint(0, 9)
        if x not in s: s.add(x)
        if len(s) == 10: constructing = False
    return s
def main():
    for x in range(10000):
        l = list(check_set())
        if l != [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]:
            print('wow')
if __name__ == '__main__':
    main()
2
mizuprogrammer 26 मार्च 2020, 23:13

1 उत्तर

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

उन इनट्स हैश को स्वयं:

>>> [*map(hash, range(10))]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

जब आप किसी सेट में 0 से 9 की संख्या जोड़ते हैं, तो सेट कम से कम 10 संख्याओं के लिए जगह बनाता है (वास्तव में 32, मुझे लगता है)। तो इसकी आंतरिक सरणी में कम से कम 0 से 9 तक अनुक्रमित होते हैं। और क्योंकि उन संख्याओं को स्वयं के लिए हैश किया जाता है, वे सेट के आंतरिक सरणी में अपने स्वयं के अनुक्रमणिका पर संग्रहीत होते हैं (मान i अनुक्रमणिका पर संग्रहीत हो जाता है hash(i) =i)। तो जब आप इसे पुनरावृत्त करते हैं, तो आप उन्हें क्रमबद्ध करते हैं।

छोटे उदाहरणों के साथ आगे का चित्रण:

सेट आंतरिक आकार 8 से शुरू होते हैं, और मान i इंडेक्स hash(i) % 8 पर जाना चाहता है। इसलिए अगर आप 0 और 8 जोड़ते हैं, तो दोनों इंडेक्स 0 में जाना चाहते हैं। जो पहले आता है वह वास्तव में 0 को इंडेक्स करता है, दूसरे को किसी अन्य (बड़े) इंडेक्स में जाना होता है। इसलिए:

>>> {0, 8}, {8, 0}
({0, 8}, {8, 0})

यदि आप इसके बजाय 1 और 8 जोड़ते हैं, तो 1 अनुक्रमणिका 1 में जाना चाहता है और 8 अनुक्रमणिका 0 पर जाना चाहता है, इसलिए 8 इंसर्शन ऑर्डर की परवाह किए बिना हमेशा पहले आता है:

>>> {1, 8}, {8, 1}
({8, 1}, {8, 1})

0 से 9 के साथ एक उदाहरण:

>>> s = set()
>>> for i in 8, 9, 0, 1, 2, 3, 4, 5, 6, 7:
        s.add(i)
        print(s)

{8}    # the only element (stored at index 0)
{8, 9}    # 9 gets stored at index 1, so after 8
{8, 9, 0}    # indices 0 and 1 are already taken, so 0 goes to some higher index
{8, 9, 0, 1}    # similar
{0, 1, 2, 8, 9}    # the set internally resized and re-added all values, each
                   # value ends up at its own index (e.g., 8 goes to index 8)
{0, 1, 2, 3, 8, 9}    # 3 goes to index 3
{0, 1, 2, 3, 4, 8, 9}    # same for the rest, all go to their own index...
{0, 1, 2, 3, 4, 5, 8, 9}
{0, 1, 2, 3, 4, 5, 6, 8, 9}
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
3
Kelly Bundy 27 मार्च 2020, 03:43