पायथन में बहुत बड़ी संख्या को संभालना

Question

मैं पायथन में तेजी से पोकर हैंड मूल्यांकन पर विचार कर रहा हूं। यह मेरे लिए हुआ कि प्रक्रिया को गति देने का एक तरीका यह होगा कि सभी कार्ड चेहरों और सूटों को अभाज्य संख्याओं के रूप में दर्शाया जाए और हाथों को दर्शाने के लिए उन्हें एक साथ गुणा किया जाए। सफेद करने के लिए:

class PokerCard:
    faces = '23456789TJQKA'
    suits = 'cdhs'
    facePrimes = [11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 53, 59, 61]
    suitPrimes = [2, 3, 5, 7]

तथा

    def HashVal(self):
      return PokerCard.facePrimes[self.cardFace] * PokerCard.suitPrimes[self.cardSuit]

इससे प्रत्येक हाथ को एक संख्यात्मक मूल्य मिलेगा, जो कि modulo के माध्यम से मुझे बता सकता है कि कितने राजा हाथ में हैं या कितने दिल हैं। उदाहरण के लिए, इसमें पाँच या अधिक क्लबों के साथ कोई भी हाथ समान रूप से 2 ^ 5 से विभाजित होगा; चार राजाओं के साथ कोई भी हाथ 59 ^ 4, आदि द्वारा समान रूप से विभाजित होगा।

समस्या यह है कि AcAdAhAsKdKhKs की तरह सात-कार्ड हाथ में लगभग 62.7 क्वाड्रिलियन का हैश मूल्य है, जो आंतरिक रूप से प्रतिनिधित्व करने के लिए 32 बिट्स से अधिक का समय लगेगा। क्या पायथन में इतनी बड़ी संख्या में स्टोर करने का एक तरीका है जो मुझे इस पर अंकगणितीय संचालन करने की अनुमति देगा?

Comments

क्या आप सुनिश्चित हैं कि, एक बार जब आप इस तरह से अपने डेटा का प्रतिनिधित्व करना शुरू करते हैं, तब भी आपको कोई महत्वपूर्ण गति सुधार दिखाई देगा? मुझे लगता है कि यह आपके सवालों का जवाब नहीं देता है, लेकिन फिर भी ..

— Thomi

मेरे पास एक सुझाव है: कार्ड मूल्यों और अभ्यावेदन के लिए अलग-अलग चर का उपयोग करने के बजाय, मैं शब्दकोशों का उपयोग करने का सुझाव देता हूं। (इसलिए चेहरे = {'2': 11, '3': 13, '4': 17, '5': 19, '6': 23, '7': 29, '8': 31, '9' : 37, 'T': 41, 'J': 43, 'Q': 53, 'K': 59, 'A': 61} और सूट = {'c': 2, 'd': 3, ' h ': 5,' s ': 7}।)

— JAB

Answer 1

पायथन एक "बिग्नम" पूर्णांक प्रकार का समर्थन करता है जो मनमाने ढंग से बड़ी संख्या के साथ काम कर सकता है। पायथन 2.5+ में, इस प्रकार को कहा जाता है longऔर यह प्रकार से अलग होता है int, लेकिन दुभाषिया स्वचालित रूप से जो भी अधिक उपयुक्त होगा, का उपयोग करेगा। पायथन 3.0+ में, दint प्रकार को पूरी तरह से छोड़ दिया गया है।

यह सिर्फ एक कार्यान्वयन विवरण है, हालांकि - जब तक आपके पास संस्करण 2.5 या बेहतर है, बस मानक गणित संचालन करें और कोई भी संख्या जो 32-बिट गणित की सीमाओं को पार करती है, स्वचालित रूप से (और पारदर्शी रूप से) एक bignum में बदल जाएगी।

आप PEP 0237 में सभी gory विवरण पा सकते हैं ।

Comments

सवाल यह है कि क्या 32 बिट पूर्णांक के बजाए बिग्नम का उपयोग करने से प्रदर्शन हिट हो जाता है, वह अपने द्वारा उपयोग किए जा रहे हाथ मूल्यांकन की चतुर विधि से प्रदर्शन लाभ से अधिक है।

— क्रिस अपचर्च 20

दरअसल, 2.5 में इंट और लॉन्ग के बीच का अवरोध टूट गया था। 3.0 पूरी तरह से पूरी तरह से हटा देता है, लंबे समय से एकमात्र पूर्णांक प्रकार बनाता है।

— इग्नासियो वाज़क्वेज़-अब्राम्स

एक बड़ी संख्या कितनी बड़ी है? क्या यह PHI ^ 4000000 हो सकता है?

— माइक कैरन

@ माइक कैरन - यदि PEP 0237 में सूचीबद्ध संरचना सटीक है, तो longs 'लंबाई (अंकों में) को अहस्ताक्षरित 32-बिट पूर्णांक के रूप में संग्रहीत किया जाता है, 4,294,967,295 अंकों तक, जिसका अर्थ है कि वे आसानी से φ ** (4 * 10 ** 6) पकड़ सकते हैं ), जो "केवल" 832,951 अंक है। हालांकि, inte पूर्णांक नहीं है, इसलिए आपको संख्या की गणना करने के लिए दशमलव (पायथन के फ्लोटिंग-पॉइंट बिग्नम) का उपयोग करना होगा। आप परिणाम को longबाद में स्टोर कर सकते हैं ।

— बेन ब्लैंक

@ इग्नासियोवेज़ज़-एब्राम सिर्फ स्पष्टीकरण का एक बिंदु है, long3.0 में एकमात्र पूर्णांक प्रकार है, लेकिन इसका नाम है int। (और पुराने intचला गया है।)

— माइकल Mior

Answer 2

अजगर मनमाने ढंग से बड़े पूर्णांक का समर्थन करता है स्वाभाविक रूप :

उदाहरण:

>>>10 ** 1000 100000000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

तुम भी एक विशाल पूर्णांक मूल्य के उदाहरण के लिए, मिल सकता है, (4000000) तंतु।

लेकिन फिर भी यह (अभी के लिए) एक मनमाने ढंग से बड़े फ्लोट का समर्थन नहीं करता है !!

यदि आपको एक बड़ा, बड़ा, फ्लोट चाहिए तो दशमलव मॉड्यूल की जांच करें। इन मंचों पर उपयोग के उदाहरण हैं: अतिप्रवाह: (34, 'परिणाम बहुत बड़ा')

एक अन्य संदर्भ: http://docs.python.org/2/library/decimal.html

अगर आपको स्पीड-अप (जो आपकी रुचि की हो) की आवश्यकता है, तो आप gmpy मॉड्यूल का उपयोग भी कर सकते हैं: कोड में बड़ी संख्या को हैंडल करना

एक अन्य संदर्भ: https://code.google.com/p/gmpy/

Answer 3

आप इसे इसके मज़े के लिए कर सकते हैं, लेकिन इसके अलावा यह एक अच्छा विचार नहीं है। यह मेरे बारे में कुछ भी गति नहीं देगा।

• एक हाथ में कार्ड प्राप्त करना एक पूर्णांक फैक्टरिंग ऑपरेशन होगा जो किसी सरणी तक पहुँचने की तुलना में बहुत अधिक महंगा है।

• कार्ड जोड़ना कई गुणा, और कार्ड विभाजन को हटाना होगा, दोनों बड़े बहु-शब्द संख्याएँ, जो सूचियों में तत्वों को जोड़ने या हटाने की तुलना में अधिक महंगा संचालन हैं।

• एक हाथ का वास्तविक संख्यात्मक मूल्य आपको कुछ भी नहीं बताएगा। आपको दो हाथों की तुलना करने के लिए primes को कारक बनाना होगा और पोकर नियमों का पालन करना होगा। ऐसे हाथों के लिए h1 <h2 का मतलब कुछ भी नहीं है।

Answer 4

अजगर स्वाभाविक रूप से बड़े पूर्णांक का समर्थन करता है:

In [1]: 59**3*61**4*2*3*5*7*3*5*7
Out[1]: 62702371781194950
In [2]: _ % 61**4
Out[2]: 0

Answer 5

अजगर दुभाषिया इसे आपके लिए संभाल लेगा, आपको बस अपना ऑपरेशन (+, -, *, /) करना होगा, और यह सामान्य रूप से काम करेगा।

intमूल्य असीमित है।

विभाजन करते समय सावधानी से, भागफल को डिफ़ॉल्ट रूप से बदल दिया जाता है float, लेकिन floatइतनी बड़ी संख्या का समर्थन नहीं करता है। यदि आपको एक त्रुटि संदेश मिलता है, जिसमें कहा गया floatहै कि यह इतनी बड़ी संख्या का समर्थन नहीं करता है, तो इसका मतलब है कि भागफल बहुत बड़ा है, floatजिसे आपको फर्श डिवीजन में उपयोग करना होगा ( //)।

यह दशमलव बिंदु के बाद आने वाले किसी भी दशमलव को अनदेखा करता है, इस तरह, परिणाम होगा int, इसलिए आपके पास बड़ी संख्या में परिणाम हो सकते हैं।

10//3 आउटपुट 3

10//4 आउटपुट 2

Comments

प्रश्न में आपका उत्तर बड़ी संख्या में कैसे जारी होता है?

— स्टुपिडॉल्फ

इसका मतलब है कि तुम सिर्फ बड़ी संख्या के साथ सामान्य कार्यों है, लेकिन विभाजन के साथ सावधान किया जा सकता है

— Hedy