गणित के सवाल पर

समय-समय पर विषयगत मंचों में होने वाले विवादों के बारे में कि क्या एक प्रोग्रामर को गणित की आवश्यकता है, लंबे समय से एक सामान्य स्थान और पवित्र युद्धों का क्षेत्र बन गया है। सीमा के हमारे (दाईं ओर) होने के कारण बुराई को अच्छाई से अलग करते हुए, मैं एक उदाहरण साझा करना चाहता हूं जो स्पष्ट रूप से दर्शाता है कि इसकी कितनी आवश्यकता है और यहां तक ​​कि (हम इस शब्द से नहीं डरेंगे) आवश्यक है।

एक दिलचस्प प्रोग्रामिंग समस्या पर विचार करें, जिसमें कुछ ओलंपियाड चरित्र है।

Pnp: इस बिंदु से आगे, इस विचार के समर्थक कि आज प्रोग्रामिंग में सुंदर रूप से डिज़ाइन किए गए वेब पेज शामिल हैं, आप पढ़ना बंद कर सकते हैं, आप बिल्कुल सही हैं, आपको गणित की आवश्यकता नहीं है ...

ठीक है, आपको इस बात पर जोर देना होगा कि आप हमसे ज्यादा बुरे नहीं हैं, और आपका काम वास्तव में महत्वपूर्ण है, क्योंकि मैं पहले ही सहमत था कि हमारे पास प्रोग्रामिंग के बारे में अलग-अलग विचार हैं ...

हां, आप बिलकुल सही हैं कि ये ऑलिम्पीड्स अंतिम ढांचे की मदद से कोड की एक लाइन में सात लाल लंब रेखाएँ नहीं खींच पाएंगे ...

फिर भी, मैं इसे अपना विचार मानता हूं जो सही है (यह प्रोटीन निकायों के रूप में अत्यधिक संगठित पदार्थ की एक घातक संपत्ति है), इसलिए मैं इसके समर्थन में तर्क प्रस्तुत करूंगा।

मैं इस समस्या को तैयार करता हूं - किसी दिए गए p बटन में लंबाई के K की कितनी अलग-अलग संख्या टेलीफोन कीपैड (कीबोर्ड) पर टाइप की जा सकती है, अगर हमें बटन के साथ शतरंज के नाइट को घुमाने की जरूरत है। यह समझा जाता है कि आपने कीबोर्ड देखा (मेरे पास अभी भी एक नियमित रूप से मोबाइल फोन है, स्मार्टफोन नहीं है, इसलिए मैं इसे हर दिन देखता हूं, एक अधिक उन्नत पाठक को मदद के लिए इंटरनेट से संपर्क करना चाहिए) और आप जानते हैं कि एक शतरंज का घोड़ा कैसे चलता है (Google के लिए आसान)। गणित का इससे अब तक कोई लेना-देना नहीं है, अगर आपके पास विकल्पों की गणना करने की क्षमता नहीं है।

पहला समाधान काफी स्पष्ट है - हम सभी 10 बटन एक के बाद एक लेते हैं (हम सामान्यता के लिए n द्वारा उनकी संख्या को निरूपित करते हैं), इसमें से लंबी K की सभी संभावित संख्याओं पर विचार करें और उन लोगों को गिनें जो वांछित बटन पर समाप्त होते हैं। परिणामी संख्याओं को संक्षेप में प्रस्तुत किया गया है और उत्तर तैयार है। देखे गए विकल्पों की कुल संख्या लगभग n * B (K) के रूप में व्यक्त की जाती है, जहां B (K) लंबाई K की संभावित चालों की संख्या है। वास्तव में, आपको n पदों की राशि पर विचार करने की आवश्यकता है, क्योंकि B (p, K) काफी स्पष्ट रूप से बटन संख्या पर निर्भर करता है लेकिन पहले अनुमान के रूप में नीचे आते हैं।

B को खोजने के लिए आगे बढ़ने से पहले, कोई भी सामान्य ज्ञान को लागू करके (नहीं, अभी तक गणित नहीं) विकल्पों की संख्या को काफी कम कर सकता है। चूंकि बटन की गति पृष्ठभूमि पर निर्भर करती है, हम कार्य को उल्टा कर सकते हैं और वांछित पी बटन से शुरू होने वाली लंबाई के सभी नंबरों की तलाश कर सकते हैं। फिर विकल्पों की कुल संख्या B (p, K) होगी, जो कि n से कम है। वाह, हमें बस 10 बार एक समाधान की खोज को तेज करने का एक तरीका मिला - शांत, चलो देखते हैं कि कितना बचा है।

हमें बी (पी, के) का मूल्यांकन करने की आवश्यकता है, जिसके लिए हम निर्धारित करते हैं कि प्रत्येक कदम पर हमारे पास घटनाओं के विकास के लिए 2 से 3 विकल्प हैं। यह (सामान्य रूप से, यह कॉम्बीनेटरिक्स है, लेकिन सहज ज्ञान युक्त) इस प्रकार है कि विकल्पों की कुल संख्या 2 ** K से 3 ** K (इसके बाद मैं K-1 का उपयोग K) के रूप में करूँगा। हम एक संभावित मॉडल पर जाकर भी इस अनुमान को बेहतर बना सकते हैं। पल में प्रत्येक बटन में उंगली की उपस्थिति को ध्यान में रखते हुए समान रूप से संभावित है (एक मजबूत बयान, सबसे अधिक गलत, लेकिन मोटे अनुमान के साथ स्वीकार्य), हम चाल विकल्पों की औसत संख्या की गणना कर सकते हैं 7 * 2 + 2 (बटन 4 और 6) * 3 / 20/9 ~ 2.22 । तब अनुमान 2.22 ** K होगा, और हम यह सुनिश्चित करने के लिए जानते हैं कि हमारे पास न्यूनतम 2 ** K है। फिर K = 100 के लिए हमें एक कम बाउंड 2 ** 100 = (2 ** 10) ** 10> (10 ** 3) ** 10 = 30 * 30 मिलता है।

यदि हम नैनोसेकंड में एक विकल्प पर विचार करते हैं (और यह एक शक्तिशाली डेस्कटॉप पीसी पर भी आसान नहीं है), तो हमें 10 ** 30/10 ** 9 = 10 ** 21 सेकंड की आवश्यकता है। इसके बाद, हम याद करते हैं कि अद्भुत मोनिकोनिक "equal सेकंड एक सदी के बराबर हैं" और आवश्यक समय 10 ** 21 / 3.14 * 10 ** 9 ~ 3 * 10 ** 11 शताब्दी होगा। यह मुझे लगता है कि कुछ पाठक प्रस्तावित पद्धति का उपयोग करके गणनाओं के अंत को देखने के लिए जीवित रहेंगे। प्रदर्शक भयानक है, केवल तथ्यात्मक उससे भी बदतर है।

हम इस तथ्य के आधार पर समाधान में सुधार करेंगे कि हम विकल्पों की संख्या में रुचि रखते हैं, लेकिन विकल्प स्वयं नहीं। आप सभी p 'के लिए स्पष्ट सूत्र B (p, K) = B (p', K-1) का योग प्रस्तुत कर सकते हैं, जिसमें हम p से 1 चाल में प्राप्त करते हैं। हम अंतिम बटन से शुरू करते हैं और इसे 1 के वजन के साथ असाइन करते हैं, फिर वर्तमान भार को अगले तक समेटने की प्रक्रिया करते हैं, वांछित गहराई तक दोहराते हैं।

हम उदाहरण देते हैं कि 1 {1234567890} से शुरू होने वाले उदाहरण के साथ क्या कहा गया था:
प्रारंभिक वजन {1000000000},
पहले हस्तांतरण के बाद {0000010100} (2 विकल्प),
दूसरे हस्तांतरण के बाद {2010001001} (5 विकल्प),
तीसरे {0102040300} (10 विकल्प) और इतने पर।

एल्गोरिदम सरल है, इसे आपके हाथों से भी लागू किया जा सकता है। निष्पादन समय का सामान्य अनुमान K पुनरावृत्तियों है, जिनमें से प्रत्येक पर n वजन के लिए हम n संबंधित भार से अधिक नहीं संशोधित करते हैं, कुल n ** 2 * K। पहले से विचार किए गए मामले के लिए, 10 * 10 * 100 = 10 ** 4 - काफी थोड़ा।

यह केवल प्रत्येक ऑपरेशन की अवधि का मूल्यांकन करने के लिए रहता है - यह इसके अलावा (कचरा प्रश्न) है, लेकिन सरल जोड़ नहीं (इस जगह से और अधिक विस्तार से)। हमने पहले से ही 2 ** K के जवाब की निचली सीमा निर्धारित कर दी है, अर्थात हमें परिणाम का प्रतिनिधित्व करने के लिए कम से कम K बिट्स की आवश्यकता है। ऊपरी सीमा 3 ** K है, हमारे मामले के लिए 3 ** 100 = (3 ** 5) ** 20 <(2 ** 8) * 20 = 2 ** 160, अर्थात्, हमें 160 बिट्स में फिट होने की गारंटी है। हम मान सकते हैं कि 128 बिट्स हमारे लिए पर्याप्त हैं, चूंकि 2.2 ** 100 <2 ** 128, लेकिन विश्वास पर इस तरह के एक बयान को स्वीकार करना डरावना है, इसलिए हमें कम से कम 160 बिट्स या 49 दशमलव अंकों के साथ एक संख्या की आवश्यकता है, जो आपकी संख्या लाइब्रेरी पर निर्भर करती है उच्च सटीकता।

पीएनपी: एक अस्थायी बिंदु की पेशकश न करें, हमें पूरी तरह से सटीक परिणाम की आवश्यकता है।
स्वीकृत मान्यताओं में, जोड़-घटाव 160/8 = 20 बाइट्स / 4 = 5 जोड़ देगा जिसमें पूर्णांक 32 बिट्स लंबे होंगे, जो किसी भी तरह से समय के क्रम को प्रभावित नहीं करता है (यह K में रैखिक रहता है), लेकिन वास्तविक गणना समय को कई गुना बढ़ा सकता है (कई बार)।

किसी भी मामले में, परिणाम केवल शानदार है - हमने कार्य को मौलिक रूप से अस्वीकार्य से उचित समय में पूरी तरह से हल करने के लिए बदल दिया: यदि एक प्राथमिक जोड़ ऑपरेशन एक माइक्रोसेकंड में किया जाता है (और यह Arduino बोर्ड पर भी सुनिश्चित करना आसान है), तो कुल समय 10 ** 4 * 20 से अधिक नहीं होगा। / 10 ** 6, एक सेकंड से कम) और हमने बिना किसी गणित के किया।

फिर भी, और अगर हमें बड़े के की जरूरत है - बेशक, गणना का रैखिक क्रम - यह बहुत अच्छा है, लेकिन यह बड़े मूल्यों के लिए महत्वपूर्ण समय की हानि का कारण बन सकता है (और करेगा)। यह पता चला है कि आप अपेक्षित समय में काफी सुधार कर सकते हैं, अपने हाथों को देख सकते हैं।

गणना के प्रत्येक चरण (छद्म-कोड) पर हम क्या करते हैं:

  = 0;
   1
    2
*  (  1     2)
*       1     2.
  =  

    2 (  1 *  )

0 1, . '=* =(...((*)*)...). , =***. , . **3, ***3 — , ? , …

— , **3 , , , ( ) ( ), . , 100 99 8. , 2*log2(), ( =100 1000/10=100 ) , 2*log2()***3. , , , . , , log2(K), , , 100.

- ( , ), , , .