कोटलिन में कार्यात्मक प्रोग्रामिंग के मेरे पसंदीदा उदाहरण

कोटलिन की एक महान विशेषता यह है कि यह कार्यात्मक प्रोग्रामिंग का समर्थन करता है। आइए एक नज़र डालते हैं और कोटलिन में लिखे गए कुछ सरल लेकिन अभिव्यंजक कार्यों पर चर्चा करते हैं।

संग्रह के साथ काम करें

कोटलिन संग्रह के साथ सुविधाजनक काम का समर्थन करता है। कई अलग-अलग विशेषताएं हैं। मान लीजिए कि हम एक विश्वविद्यालय के लिए कुछ प्रणाली बनाते हैं। हमें उन सर्वोत्तम छात्रों को खोजने की आवश्यकता है जो छात्रवृत्ति के पात्र हैं। हमारे पास निम्नलिखित Student मॉडल हैं:

 class Student( val name: String, val surname: String, val passing: Boolean, val averageGrade: Double ) 

अब हम सभी मानदंडों को पूरा करने वाले शीर्ष दस छात्रों की सूची प्राप्त करने के लिए निम्नलिखित फ़ंक्शन को कॉल कर सकते हैं:

 students.filter { it.passing && it.averageGrade > 4.0 } // 1 .sortedBy { it.averageGrade } // 2 .take(10) // 3 .sortedWith(compareBy({ it.surname }, { it.name })) // 4 

• हम केवल उन छात्रों को छोड़ते हैं जिन्होंने परीक्षा उत्तीर्ण की है, जिनका औसत स्कोर 4.0 से अधिक है।
• औसत स्कोर द्वारा उन्हें क्रमबद्ध करें।
• हम पहले दस छात्रों को छोड़ देते हैं।
• उन्हें वर्णानुक्रम में क्रमबद्ध करें। तुलनित्र पहले अंतिम नामों की तुलना करता है, और यदि वे समान हैं, तो यह नामों की तुलना करता है।

क्या होगा अगर, वर्णमाला के क्रम के बजाय, हमें छात्रों के मूल क्रम को बनाए रखने की आवश्यकता है? हम इसे इंडेक्स का उपयोग करके कर सकते हैं:

 students.filter { it.passing && it.averageGrade > 4.0 } .withIndex() // 1 .sortedBy { (i, s) -> s.averageGrade } // 2 .take(10) .sortedBy { (i, s) -> i } // 3 .map { (i, s) -> s } // 4 

• प्रत्येक तत्व के लिए वर्तमान पुनरावृत्ति सूचकांक को बांधें।
• औसत अंक के आधार पर छाँटें और पहले दस छात्रों को छोड़ दें।
• फिर से क्रमबद्ध करें, लेकिन अब सूचकांक द्वारा।
• हम इंडेक्स हटाते हैं और केवल छात्रों को छोड़ते हैं।

यह उदाहरण दर्शाता है कि कोटलिन में संग्रह के साथ काम कितना सरल और सहज है।

सुपरसेट (बुलियन)

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

{1,2,3}

वह उनका सुपरसेट है:

{{}, {1}, {2}, {3}, {1,2}, {1,3}, {2,3}, {1,2,3}}

बीजगणित में, इस तरह के एक समारोह बहुत उपयोगी है। हम इसे कैसे लागू करते हैं?

अगर आप खुद को चुनौती देना चाहते हैं, तो अभी से पढ़ना बंद कर दें और इस समस्या को खुद सुलझाने की कोशिश करें।

आइए एक सरल अवलोकन के साथ अपना विश्लेषण शुरू करें। यदि हम सेट के कुछ तत्व लेते हैं (उदाहरण के लिए, 1), तो सुपर-सेट में इस तत्व के बराबर सेट होंगे ({1}, {1,2}, {1,3}, {1,2,3}) और इसके बिना ({}, {2}, {3}, {2,3})।

ध्यान दें कि दूसरा सेट एक सुपर-सेट ({2,3}) है, और पहला सेट के लिए हमारे अतिरिक्त तत्व (1) के साथ एक सुपर-सेट ({2,3}) है। इस प्रकार, हम पहले तत्व को ले कर सुपरसेट की गणना कर सकते हैं, अन्य सभी के लिए सुपरसेट की गणना कर सकते हैं और परिणाम का योग और परिणाम को पहले सेट के साथ प्रत्येक सेट में जोड़ सकते हैं:

 fun <T> powerset(set: Set<T>): Set<Set<T>> { val first = set.first() val powersetOfRest = powerset(set.drop(1)) return powersetOfRest.map { it + first } + powersetOfRest } 

लेकिन यह तरीका काम नहीं करेगा। समस्या एक खाली सेट है: first सेट खाली होने पर एक त्रुटि होगी। यहां एक सुपरसेट की परिभाषा बचाव में आती है - एक खाली सेट का सुपरसेट एक खाली सेट है: पावरसेट ({}) = {{}}। यहाँ सही एल्गोरिदम कैसा दिखता है:

 fun <T> powerset(set: Set<T>): Set<Set<T>> = if (set.isEmpty()) setOf(emptySet()) else { val powersetOfRest = powerset(set.drop(1)) powersetOfRest + powersetOfRest.map { it + set.first() } } 

आइए देखें कि यह कैसे काम करता है। मान लीजिए हमें पॉवरसेट ({1,2,3}) की गणना करने की आवश्यकता है। एल्गोरिथ्म निम्नानुसार कार्य करेगा:

पावरसेट ({1,2,3}) = पावरसेट ({2,3}) + पावरसेट ({2,3})। मैप {यह + 1}}

पावरसेट ({2,3}) = पावरसेट ({3}) + पावरसेट ({3})। मैप {इट + 2}

पावरसेट ({3}) = पावरसेट ({}) + पावरसेट ({})। मैप {इट + 3}

पावरसेट ({}) = {{}}

पॉवरसेट ({3}) = {{}, {3}}

शक्तियों ({2,3}) = {{}, {3}} + {2}, {2, 3}} = {{}, {2}, {3}, {2, 3}}

पावरसेट ({1,2,3}) = {{}, {2}, {3}, {2, 3}} + {{1}, {1, 2}, {1, 3}, {1 2, 3}} = {{}, {1}, {2}, {3}, {1,2}, {1,3}, {2,3}, {1,2,3}}

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

 fun <T> powerset(set: Set<T>): Set<Set<T>> = if (set.isEmpty()) setOf(emptySet()) else powerset(set.drop(1)) .let { it+ it.map { it + set.first() } 

हम इस फ़ंक्शन को Collection लिए एक एक्सटेंशन फ़ंक्शन के रूप में भी परिभाषित कर सकते हैं, ताकि हम इस फ़ंक्शन का उपयोग कर सकें जैसे कि यह Set ( setOf(1,2,3).powerset() powerset(setOf(1,2,3)) बजाय powerset(setOf(1,2,3)) ):

 fun <T> Collection<T>.powerset(): Set<Set<T>> = if (isEmpty()) setOf(emptySet()) else drop(1) .powerset() .let { it+ it.map { it + first() } 

हम बनाई गई पुनरावृत्ति के नकारात्मक प्रभावों को भी कम कर सकते हैं। उपरोक्त कार्यान्वयन में, सुपरसेट की स्थिति प्रत्येक पुनरावृत्ति के साथ बढ़ती है (प्रत्येक पुनरावर्ती कॉल के साथ), क्योंकि पिछले पुनरावृत्ति की स्थिति को स्मृति में संग्रहीत किया जाना चाहिए।

इसके बजाय, हम एक नियमित लूप या tailrec फ़ंक्शन tailrec उपयोग कर सकते हैं। हम फ़ंक्शन की पठनीयता बनाए रखने के लिए दूसरे विकल्प का उपयोग करेंगे। tailrec संशोधक निष्पादित अंतिम फ़ंक्शन लाइन में केवल एक पुनरावर्ती कॉल की अनुमति देता है। यहां बताया गया है कि हम इसे और अधिक कुशलता से उपयोग करने के लिए अपना फ़ंक्शन कैसे बदल सकते हैं:

 fun <T> Collection<T>.powerset(): Set<Set<T>> = powerset(this, setOf(emptySet())) private tailrec fun <T> powerset(left: Collection<T>, acc: Set<Set<T>>): Set<Set<T>> = if (left.isEmpty()) acc else powerset(left.drop(1), acc + acc.map { it + left.first() }) 

यह कार्यान्वयन KotlinDiscreteMathToolkit पुस्तकालय का हिस्सा है, जो असतत गणित में उपयोग किए जाने वाले कई अन्य कार्यों को परिभाषित करता है।

Quicksort (quicksort)

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

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

 fun <T : Comparable<T>> List<T>.quickSort(): List<T> = if(size < 2) this else { val pivot = first() val (smaller, greater) = drop(1).partition { it <= pivot} smaller.quickSort() + pivot + greater.quickSort() } // Usage listOf(2,5,1).quickSort() // [1,2,5] 

बहुत खूबसूरत लग रही है, है ना? यह कार्यात्मक प्रोग्रामिंग की सुंदरता है।

ऐसे फ़ंक्शन के साथ पहली समस्या इसका निष्पादन समय है। वह पूरी तरह से असंयमित है। लेकिन यह छोटा और पढ़ने में आसान है।

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

 val r = Random() listOf(100_000, 1_000_000, 10_000_000) .asSequence() .map { (1..it).map { r.nextInt(1000000000) } } .forEach { list: List<Int> -> println("Java stdlib sorting of ${list.size} elements took ${measureTimeMillis { list.sorted() }}") println("quickSort sorting of ${list.size} elements took ${measureTimeMillis { list.quickSort() }}") } 

यहां हमें मिले परिणाम हैं:

100000 तत्वों की छंटनी की जावा stdlib 83
१००००० तत्वों की छँटाई क्विकॉर्ट ने १६३ ली
1,000,000 तत्वों की जावा stdlib छँटाई 558 हुई
1,000,000 तत्वों में से क्विकसॉर्ट सॉर्टिंग में 859 लगे
जावा stdlib 10,000,000 तत्वों की छंटनी ने 6182 लिया
१०,०००,००० तत्वों की क्विकसॉर्ट छँटाई १२१३३ हुई

जैसा कि आप देख सकते हैं, quickSort फ़ंक्शन लगभग 2 गुना धीमा है। विशाल सूचियों के लिए भी। सामान्य मामलों में, अंतर आमतौर पर 0.1ms से 0.2ms तक होगा। यह बताता है कि क्यों कुछ मामलों में हम एक फ़ंक्शन का उपयोग कर सकते हैं जो थोड़ा कम अनुकूलित है, लेकिन अच्छी तरह से पठनीय और सरल है।