एल्गोरिदम का वर्णन कैसे करें, उन्हें साबित करें और उनका विश्लेषण करें?

Question

द आर्ट ऑफ़ कंप्यूटर प्रोग्रामिंग (TAOCP) पढ़ने से पहले , मैंने इन सवालों पर गहराई से विचार नहीं किया है। मैं एल्गोरिदम का वर्णन करने के लिए छद्म कोड का उपयोग करूंगा, उन्हें समझूंगा और केवल विकास के आदेशों के बारे में चल रहे समय का अनुमान लगा सकता हूं। TAOCP अच्छी तरह से मेरे मन बदल जाता है।

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

यह लेखक का तर्क है कि हम वास्तव में समझते हैं कि एक एल्गोरिथ्म केवल तभी मान्य है जब हम इस बिंदु पर पहुंचते हैं कि हमारे दिमाग में सभी सिद्धांतों में स्पष्ट रूप से भरा हुआ है, जैसा कि Fig.4 में किया गया था।

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

विकास के आदेशों का विश्लेषण कभी-कभी बेकार होता है। उदाहरण के लिए, हम क्योंकि वे कर रहे हैं heapsort से quicksort भेद नहीं कर सकते सब $E(T(n))=\Theta(n\log n)$ , जहां $EX$ यादृच्छिक चर की अपेक्षित संख्या है $X$ , तो हम लगातार विश्लेषण करना चाहिए, कहते हैं, $E(T_1(n))=A_1n\lg n+B_1n+O(\log n)$और $E(T_2(n))=A_2\lg n+B_2n+O(\log n)$ , इस प्रकार हम $T_1$ और तुलना $T_2$बेहतर कर सकते हैं । और भी, कभी-कभी हमें अन्य मात्राओं की तुलना करनी चाहिए, जैसे कि भिन्नता। केवल चल रहे समय के विकास के आदेशों का एक मोटा विश्लेषण पर्याप्त नहीं है। TAOCP के रूप में असेंबली भाषा में एल्गोरिदम का अनुवाद करता है और चल रहे समय की गणना करता है, यह मेरे लिए बहुत कठिन है, इसलिए मैं कुछ तकनीकों को जानना चाहता हूं ताकि रनिंग टाइम का थोड़ा और अधिक मोटे तौर पर विश्लेषण किया जा सके, जो उच्च स्तरीय भाषाओं जैसे सी, सी ++ के लिए भी उपयोगी है। या छद्म कोड।

और मैं यह जानना चाहता हूं कि शोध कार्यों में मुख्य रूप से किस शैली का वर्णन किया गया है, और इन समस्याओं का इलाज कैसे किया जाए।

Comments

एल्गोरिदम के निष्पादन समय की बारीकी से तुलना करते समय आपको बहुत सावधान रहना चाहिए। रियल कंप्यूटर में कैश, रजिस्टर और पाइपलाइन होते हैं, जो बहुत तेजी से चल रहे समय को बदल सकते हैं। यदि आप यह पता लगाना चाहते हैं कि कौन सा एल्गोरिदम वास्तव में तेज है, तो आपको वास्तव में इसे कंप्यूटर पर चलाना होगा।

— svick

वास्तव में, इस तरह के नुथ का उपयोग करता है के रूप में कोडांतरक विश्लेषण है जिस तरह से वास्तविक जीवन कोड का विश्लेषण करने के लिए कुछ भी नहीं है क्योंकि छिपा हुआ है और नियंत्रण प्रवाह आसान है की तुलना में आसान। आप अभ्यास के लिए पूछ रहे हैं; मुझे लगता है कि डेव की टिप्पणी लागू होती है। अभ्यास करने वालों को कठोर विश्लेषण करने की तुलना में रनटाइम माप का उपयोग करके अपने एल्गोरिदम को इंजीनियर करने की अधिक संभावना है। लेकिन फिर, मैं कोई अभ्यासी नहीं हूं, इसलिए जो मैं नमक के दाने के साथ कहता हूं वह ले लो।

— राफेल

@ राफेल माय इन प्रैक्टिस का मतलब है कि शोध कार्यों के अभ्यास में , प्रोग्रामिंग नहीं ।

— यईपाहा

@ फ्रेंक, आपको विचरण से क्या मतलब है ? मेरे प्रदर्शन परीक्षण मुझे टाइमिंग संस्करण देते हैं।

— edA-qa mort-ora-y

@ राफेल, आपका पहला बिंदु यह अब वास्तव में सच नहीं है। आधुनिक चिप्स आपके असेंबली को फिर से चालू करते हैं, स्टोर करते हैं / आउट-ऑफ-ऑर्डर लोड करते हैं, और भविष्य कहनेवाला रनिंग और लोडिंग करते हैं। संगामिति, और पिछले मुद्दों के लिए, गहन विश्लेषण वास्तव में आवश्यक है, लेकिन मैं इसे औपचारिक रूप में नहीं करता हूं।

— edA-qa mort-ora-y

Answer 1

व्यवहार्य दृष्टिकोण की एक विशाल विविधता है। जो सबसे उपयुक्त है वह निर्भर करता है

• जो आप दिखाना चाह रहे हैं,
• आपको कितना विवरण चाहिए या आवश्यकता है।

यदि एल्गोरिथ्म एक व्यापक रूप से ज्ञात है जिसे आप सबरूटीन के रूप में उपयोग करते हैं, तो आप अक्सर उच्च स्तर पर रहते हैं। यदि एल्गोरिथ्म जांच के तहत मुख्य वस्तु है, तो आप शायद अधिक विस्तृत होना चाहते हैं। विश्लेषण के लिए भी ऐसा ही कहा जा सकता है: यदि आपको किसी ऊपरी ऊपरी क्रम की आवश्यकता है तो जब आप बयानों की सटीक गणना चाहते हैं तो आप उससे अलग तरीके से आगे बढ़ते हैं।

मैं आपको प्रसिद्ध एल्गोरिथ्म मर्जेसॉर्ट के लिए तीन उदाहरण दूंगा जो उम्मीद करते हैं कि यह सचित्र है।

ऊँचा स्तर

एल्गोरिथ्म मर्जेसर्ट एक सूची लेता है, इसे दो (लगभग) समान रूप से लंबे हिस्सों में विभाजित करता है, उन आंशिक सूचियों पर पुनरावृत्ति करता है और विलय (हल) करता है ताकि अंतिम-परिणाम हल हो। सिंगलटन या रिक्त सूचियों पर, यह इनपुट लौटाता है।

यह एल्गोरिथ्म स्पष्ट रूप से एक सही सॉर्टिंग एल्गोरिथ्म है। सूची को विभाजित करना और इसे विलय करना प्रत्येक को समय में लागू किया जा सकता है , जो हमें सबसे खराब स्थिति रनटाइम टी ( एन ) = 2 टी ( एन ) के लिए पुनरावृत्ति देता है$\Theta(n)$। द्वारा मास्टर प्रमेय, को यह मूल्यांकन करता हैटी(एन)∈Θ(nलॉग इन करेंn)।$T(n) = 2T\left(\frac{n}{2}\right) + \Theta(n)$$T(n) \in \Theta(n\log n)$

मध्यम स्तर

एल्गोरिथ्म मर्ज्सर्ट निम्नलिखित छद्म कोड द्वारा दिया गया है:

procedure mergesort(l : List) {
  if ( l.length < 2 ) {
    return l
  }

  left  = mergesort(l.take(l.length / 2)
  right = mergesort(l.drop(l.length / 2)
  result = []

  while ( left.length > 0 || right.length > 0 ) {
    if ( right.length == 0 || (left.length > 0 && left.head <= right.head) ) {
      result = left.head :: result
      left = left.tail
    }
    else {
      result = right.head :: result
      right = right.tail
    }
  }

  return result.reverse
}

हम इंडक्शन द्वारा शुद्धता साबित करते हैं। लंबाई शून्य या एक की सूची के लिए, एल्गोरिथ्म तुच्छ रूप से सही है। प्रेरण परिकल्पना के रूप में, मान लें कि कुछ मनमाने ढंग से, लेकिन निश्चित प्राकृतिक n > 1 के लिए mergesortसबसे अधिक लंबाई की सूचियों पर सही ढंग से किया जाता है । अब L को लंबाई n + 1 की सूची दें । प्रेरण परिकल्पना द्वारा, और पहले सम्मान के छांटे गए (गैर-डिक्रिप्ट) छांटे गए संस्करण। पुनरावर्ती कॉल के बाद एल की दूसरी छमाही । इसलिए, लूप हर पुनरावृत्ति में चयन करता है सबसे छोटा तत्व जो अभी तक जांच नहीं किया गया है और इसे जोड़ता है ; इस प्रकार सभी तत्वों से युक्त एक गैर-तेजी से क्रमबद्ध सूची है$n$$n>1$$L$$n+1$leftright$L$whileresultresultleft और और right। रिवर्स L का एक गैर-डिक्रिप्टली सॉर्ट किया गया संस्करण है$L$ , जो लौटा है - और वांछित - परिणाम।

रनटाइम के लिए, आइए हम तत्वों की तुलना और सूची संचालन (जो कि रनटाइम पर विषमतापूर्वक हावी हो) की गणना करें। लंबाई की सूची न तो दो कारणों से कम है। लंबाई की सूची के लिए , हमारे पास पुनरावर्ती कॉल के लिए इनपुट तैयार करने के कारण होने वाले ऑपरेशन हैं, जो पुनरावर्ती कॉल से खुद को प्लस लूप और एक । दोनों पुनरावर्ती मापदंडों की गणना प्रत्येक n सूची संचालन में की जा सकती है। पाश वास्तव में क्रियान्वित किया जाता है n सबसे एक तत्व तुलना में कई बार और हर यात्रा का कारण बनता है और ठीक दो सूची आपरेशनों। 2 एन का उपयोग करने के लिए अंतिम लागू किया जा सकता है$n>1$whilereverse$n$while$n$reverse$2n$सूची संचालन - हर तत्व को इनपुट से हटा दिया जाता है और आउटपुट सूची में डाल दिया जाता है। इसलिए, ऑपरेशन गणना निम्न पुनरावृत्ति को पूरा करती है:

$\qquad \begin{align}T(0) = T(1) &= 0 \\ T(n) &\leq T\left(\left\lceil\frac{n}{2}\right\rceil\right) + T\left(\left\lfloor\frac{n}{2}\right\rfloor\right) + 7n\end{align}$

जैसा कि स्पष्ट रूप से कम नहीं है, यह एसिम्प्टोटिक विकास के लिए n = 2 k पर विचार करने के लिए पर्याप्त है । इस मामले में , पुनरावृत्ति सरल हो जाती है$T$$n=2^k$

$\qquad \begin{align}T(0) = T(1) &= 0 \\ T(n) &\leq 2T\left(\frac{n}{2}\right) + 7n\end{align}$

मास्टर प्रमेय के अनुसार, हम पाते हैं , जिनमें से क्रम तक फैली ।$T \in \Theta(n \log n)$mergesort

अति निम्न स्तर

इसाबेल / एचओएल में मर्जेसर्ट के इस (सामान्यीकृत) कार्यान्वयन पर विचार करें :

types dataset  =  "nat * string"

fun leq :: "dataset \<Rightarrow> dataset \<Rightarrow> bool" where
   "leq (kx::nat, dx) (ky, dy) = (kx \<le> ky)"

fun merge :: "dataset list \<Rightarrow> dataset list \<Rightarrow> dataset list" where
"merge [] b = b" |
"merge a [] = a" |
"merge (a # as) (b # bs) = (if leq a b then a # merge as (b # bs) else b # merge (a # as) bs)"

function (sequential) msort :: "dataset list \<Rightarrow> dataset list" where
  "msort []  = []" |
  "msort [x] = [x]" |
  "msort l   = (let mid = length l div 2 in merge (msort (take mid l)) (msort (drop mid l)))"
by pat_completeness auto
  termination
  apply (relation "measure length")
by simp+

इसमें पहले से ही अच्छी तरह से परिभाषित और समाप्ति के प्रमाण शामिल हैं। एक (लगभग) पूर्ण शुद्धता प्रमाण यहां खोजें ।

"रनटाइम" के लिए, जो तुलनाओं की संख्या है, पूर्व खंड में एक के समान पुनरावृत्ति स्थापित की जा सकती है। मास्टर प्रमेय का उपयोग करने और स्थिरांक को भूलने के बजाय, आप इसका अनुमान लगाने के लिए इसका विश्लेषण भी कर सकते हैं कि यह सत्यता की मात्रा के बराबर है। आप [1] में पूर्ण विश्लेषण पा सकते हैं; यहाँ एक कठिन रूपरेखा है (यह जरूरी नहीं कि इसाबेल / एचओएल कोड फिट हो):

जैसा कि ऊपर, तुलना की संख्या के लिए पुनरावृत्ति है

$\qquad \begin{align}f_0 = f_1 &= 0 \\ f_n &= f_{\left\lceil\frac{n}{2}\right\rceil} + f_{\left\lfloor\frac{n}{2}\right\rfloor} + e_n\end{align}$

जहाँ आंशिक परिणाम को विलय करने के लिए आवश्यक तुलनाओं की संख्या है। मंजिलों और छतों से छुटकारा पाने के लिए, हम एक मामले में भेद करते हैं कि क्या n भी है:$e_n$$n$

$\qquad \displaystyle \begin{cases} f_{2m} &= 2f_m + e_{2m} \\ f_{2m+1} &= f_m + f_{m+1} + e_{2m+1} \end{cases}$

नेस्ट का उपयोग कर आगे / पीछे मतभेद की और ई एन हमें वह समझ$f_n$$e_n$

।$\qquad \displaystyle \sum\limits_{k=1}^{n-1} (n-k) \cdot \Delta\kern-.2em\nabla f_k = f_n - nf_1$

यह राशि पेरोन के सूत्र के दाईं ओर से मेल खाती है । हम परिभाषित Dirichlet पैदा श्रृंखला की रूप में$\Delta\kern-.2em\nabla f_k$

$\qquad \displaystyle W(s) = \sum\limits_{k\geq 1} \Delta\kern-.2em\nabla f_k k^{-s} = \frac{1}{1-2^{-s}} \cdot \underbrace{\sum\limits_{k \geq 1} \frac{\Delta\kern-.2em\nabla e_k}{k^s}}_{=:\ \boxminus(s)}$

जो पेरोन के सूत्र के साथ मिलकर हमें आगे ले जाता है

।$\qquad \displaystyle f_n = nf_1 + \frac{n}{2\pi i} \int\limits_{3-i\infty}^{3+i\infty} \frac{\boxminus(s)n^s}{(1-2^{-s})s(s+1)}ds$

का मूल्यांकन इस बात पर निर्भर करता है कि किस मामले का विश्लेषण किया गया है। उसके अलावा, हम कर सकते हैं - कुछ प्रवंचना के बाद - लागू अवशेषों प्रमेय पाने के लिए$\boxminus(s)$

$\qquad \displaystyle f_n \sim n \cdot \log_2(n) + n \cdot A(\log_2(n)) + 1$

जहाँ [ - 1 , - 0.9 ] में मानों के साथ एक आवधिक कार्य है ।$A$$[-1,-0.9]$

---

1. मेलिन ट्रांसफॉर्म और एसिम्पोटिक्स: फ्लाजोलेट और गोलिन (1992) द्वारा मर्जोर्ट पुनरावृत्ति
2. $e_n = \left\lfloor\frac{n}{2}\right\rfloor$
   $e_n = n-1$
   $e_n = n - \frac{\left\lfloor\frac{n}{2}\right\rfloor}{\left\lceil\frac{n}{2}\right\rceil + 1} - \frac{\left\lceil\frac{n}{2}\right\rceil}{\left\lfloor\frac{n}{2}\right\rfloor + 1}$

Comments

$\alpha$$\beta$$T(n)=T(\lfloor n/2\rfloor)+T(\lceil n/2\rceil)+\alpha n+\beta$

@ फ्रेंक: संक्षिप्त उत्तर है आप नहीं कर सकते ; स्थिरांक कार्यान्वयन विवरण पर निर्भर करते हैं - मशीन वास्तुकला, भाषा और संकलक सहित - जो अंतर्निहित एल्गोरिथ्म के लिए सारहीन हैं।

— जेफ

$\alpha$$\beta$

@JeffE उदाहरण के लिए, Taix में MIX / MMIX है, लेकिन इस तरह की मशीन भाषा के लिए एल्गोरिथ्म का अनुवाद करना बहुत कठिन है।

— याईपाह

$\alpha$$\beta$

Answer 2

दिज्क्स्ट्रा का "प्रोग्रामिंग का एक अनुशासन" सभी एल्गोरिदम का विश्लेषण करने और साबित करने के लिए है और साबित करने के लिए डिज़ाइन किया गया है। उस पुस्तक की प्रस्तावना में, दिक्जस्त्र बताते हैं कि कैसे एक बहुत ही सरल निर्मित मिनी-भाषा है जिसे ठीक से डिज़ाइन किया गया है ताकि कई एल्गोरिदम को औपचारिक रूप से समझाया जा सके:

इस तरह एक किताब पर शुरू करते समय, एक को तुरंत इस सवाल का सामना करना पड़ता है: "मैं किस प्रोग्रामिंग भाषा का उपयोग करने जा रहा हूं?", और यह नहीं हैप्रस्तुति का मात्र प्रश्न! एक सबसे महत्वपूर्ण, लेकिन सबसे मायावी भी, किसी भी उपकरण का पहलू इसका उन लोगों की आदतों पर प्रभाव है जो इसके उपयोग में खुद को प्रशिक्षित करते हैं। यदि उपकरण एक प्रोग्रामिंग भाषा है, तो यह प्रभाव है - चाहे हम इसे पसंद करें या न करें - हमारी सोच की आदतों पर प्रभाव। मेरे सर्वोत्तम ज्ञान पर उस प्रभाव का विश्लेषण करने के बाद, मैं इस निष्कर्ष पर पहुंचा था कि मौजूदा प्रोग्रामिंग भाषाओं में से कोई भी, और न ही उनमें से एक उपसमुच्चय, मेरे उद्देश्य के अनुरूप होगा; दूसरी ओर मैं अपने आप को एक नई प्रोग्रामिंग भाषा के डिजाइन के लिए इतना पहले से ही जानता था कि मैंने अगले पांच वर्षों तक ऐसा नहीं करने का संकल्प लिया था, और मुझे सबसे अलग अहसास था कि वह अवधि अभी तक समाप्त नहीं हुई थी! (इससे पहले, कई अन्य बातों के अलावा, यह मोनोग्राफ लिखना पड़ा था।

बाद में वह बताते हैं कि अपनी लघु-भाषा को पाने में वह कितना छोटा था।

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