निर्देश
किसी खेल के खिलाड़ी की हाई स्कोर ऐरे संभालिए।
आपको क्लासिक Frogger खेल का हाई स्कोर कंपोनेंट बनाना है। Frogger अब तक के सबसे अधिक बिकने वाले और सबसे लत लगाने वाले खेलों में से एक है, और आर्केड युग का एक क्लासिक भी।
आपको ऐसे मेथड लिखने हैं जो ऐरे से सबसे अधिक स्कोर, सबसे बाद में जोड़ा गया स्कोर और सबसे अधिक वाले तीन स्कोर लौटाते हैं।
इस अभ्यास में आप लिस्ट और ऐरे के साथ काम करेंगे।
Lean में ये दोनों बहुत महत्वपूर्ण डेटा स्ट्रक्चर हैं।
लिस्ट
ज़्यादातर फंक्शनल भाषाओं की तरह, Lean में भी लिस्ट एक बुनियादी डेटा स्ट्रक्चर है।
एक लिस्ट के दो कंस्ट्रक्टर होते हैं: एक खाली लिस्ट के लिए ([]), और दूसरा ऐसी लिस्ट के लिए जिसमें एक एलिमेंट (head) और एक और लिस्ट (tail) होती है।
:: की मदद से लिस्ट में आगे एलिमेंट जोड़े जा सकते हैं, और इस तरह एक नई लिस्ट बन जाती है:
let list := x :: xs -- prepending x to xs creates a new list where x is the head and xs is the tail
लिस्टें स्वभाव से ही रिकर्सिव होती हैं, इसलिए ये आगमनात्मक तर्क के लिए बहुत उपयुक्त हैं।
ये स्ट्रक्चरल शेयरिंग भी करती हैं: आप मौजूदा लिस्ट की कॉपी बनाए बिना उसमें एक नया एलिमेंट आगे जोड़ सकते हैं:
let list1 := [1, 2]
let list2 := 0 :: list1
-- now both list1 and list2 share [1, 2]
लेकिन लिस्ट पर होने वाले ज़्यादातर ऑपरेशन में लगने वाला समय उसकी लंबाई के अनुपात में बढ़ता है, क्योंकि अगले एलिमेंट तक पहुँचने के लिए हर एलिमेंट से गुज़रना पड़ता है।
ऐरे
ऐरे मेमोरी का एक ऐसा लगातार ब्लॉक है जिसका आकार डायनामिक होता है।
कई ऑपरेशनों में ऐरे, लिस्ट से कहीं ज़्यादा कुशल हो सकते हैं:
- ऐरे के किसी भी एलिमेंट तक पहुँचना तेज़ होता है और इसमें लगने वाला समय स्थिर रहता है।
- ऐरे, डायनामिक ऐरे के आधार पर बनाए गए हैं, जो कैश लोकैलिटी की वजह से आधुनिक सिस्टम पर खासतौर से कुशल होते हैं।
लेकिन ऐरे, स्ट्रक्चरल शेयरिंग के लिए बहुत अनुकूल नहीं हैं।
आम तौर पर, फंक्शनल तरीके से काम करते समय ऐरे को अपडेट करने के लिए पूरे मौजूदा ऐरे की कॉपी बनानी पड़ती है।
Lean इस कमी को कम करने के लिए रेफरेंस काउंटिंग का इस्तेमाल करता है।
जब तक किसी ऐरे के लिए एक से ज़्यादा रेफरेंस कभी न हों (यानी उसका इस्तेमाल लीनियर ढंग से हो), तब तक कोई कॉपी नहीं बनती और बदलाव सीधे उसी जगह किए जा सकते हैं।
Array API के कई फंक्शन डेटा शेयर न होने की स्थिति में सीधे उसी जगह बदलाव करते हैं, जैसे set और push।
डू-नोटेशन
Lean डू-नोटेशन का समर्थन करता है, जो इम्परेटिव शैली में कोड लिखने के लिए एक एम्बेडेड भाषा है।
किसी do ब्लॉक के अंदर आप mut कीवर्ड की मदद से ऐसे लोकल वेरिएबल घोषित कर सकते हैं जिन्हें बदला जा सकता है और फिर से असाइन किया जा सकता है।
ऐरे जैसे डेटा स्ट्रक्चर के साथ इस्तेमाल करने पर, Lean का रनटाइम सिस्टम जब भी यह सुरक्षित हो, अंदर ही अंदर उसी जगह बदलाव कर सकता है।
डू-नोटेशन का इस्तेमाल सिर्फ किसी मोनैड के अंदर ही किया जा सकता है।
इम्परेटिव शैली में ऐसा कोड लिखने का एक आसान तरीका, जो प्योर रहे और जिसका कोई दिखने वाला साइड इफेक्ट न हो, आइडेंटिटी मोनैड का इस्तेमाल करना है:
def sumArray (array : Array Nat) := Id.run do
let mut sum := 0
for element in array do
sum := sum + element
return sum
स्रोत
अस्सी के दशक के आर्केड गेम Frogger को श्रद्धांजलि
