परिचय
ऐरे
Cairo की कोर लाइब्रेरी में एक Array टाइप होता है।
यह दूसरी प्रोग्रामिंग भाषाओं में मिलने वाले सामान्य ऐरे टाइप जैसा ही है, लेकिन इसमें कुछ खास अंतर हैं:
- एलिमेंट को कुशलता से सिर्फ
Array टाइप के पीछे ही जोड़ा जा सकता है, और उन्हें कुशलता से सिर्फ सामने से ही हटाया जा सकता है।
- ऐरे इंडेक्स की मदद से किसी एलिमेंट को मैन्युअली सेट करना संभव नहीं है।
ऐरे बनाने के लिए ArrayTrait::new फंक्शन और array! मैक्रो, दोनों का इस्तेमाल किया जा सकता है:
let empty: Array<u32> = ArrayTrait::new();
let one_to_four = array![1, 2, 3, 4];
ArrayTrait::append फंक्शन से ऐरे में एलिमेंट जोड़े जा सकते हैं:
let mut num_array = array![1, 2, 3, 4];
num_array.append(5);
// -> [1, 2, 3, 4, 5]
ArrayTrait::pop_front फंक्शन से ऐरे से एलिमेंट हटाए जा सकते हैं:
let mut one_to_four = array![1, 2, 3, 4];
one_to_four.pop_front();
// -> [2, 3, 4]
Cairo में एक Span टाइप भी है, जो Array के "स्नैपशॉट" की तरह काम करता है।
हर Array को ToSpanTrait::span फंक्शन से Span में बदला जा सकता है:
let one_to_four = array![1, 2, 3, 4];
let one_to_four_span = one_to_four.span();
// -> [1, 2, 3, 4]
ऐरे को Span में बदलना बहुत कुशल होता है। Span बस एक डेटा स्ट्रक्चर है जो Cairo को ऐरे के एक हिस्से को "देखने" देता है, और स्पैन ऐरे में कोई बदलाव नहीं करता।
ऐरे को Span में बदलने से Cairo ऐसे और भी ऑपरेशन कर पाता है जो सीधे Array पर नहीं किए जा सकते, जैसे स्पैन के सामने से कोई एलिमेंट हटाना।
let one_to_four = array![1, 2, 3, 4];
let mut one_to_four_span = one_to_four.span();
one_to_four_span.pop_back();
// -> [2, 3, 4]
ध्यान दीजिए कि pop_back को कॉल करने के लिए हमें one_to_four_span को mut कीवर्ड से म्यूटेबल बनाना पड़ा। pop_back स्पैन को बदल देता है, क्योंकि यह ऐरे के उस हिस्से को छोटा कर देता है जिसे स्पैन "देख" रहा है।
निर्देश
जादूगर बनने की तैयारी कर रही एलिस को कुछ बुनियादी बातों का अभ्यास करना है।
उसके पास कार्डों का एक ढेर है, जिसके साथ वह तरह-तरह के काम करना चाहती है।
इसे थोड़ा आसान बनाने के लिए वह सिर्फ 1 से 10 तक के कार्ड इस्तेमाल करती है।
कार्डों के इस ढेर को एक Array से दर्शाया जाता है। ढेर का सबसे नीचे वाला कार्ड ऐरे में सबसे आगे होता है और सबसे ऊपर वाला कार्ड सबसे पीछे।
1. ढेर के ऊपर एक कार्ड डालिए
फंक्शन insert_top बनाइए, जो ढेर की एक कॉपी लौटाता है जिसमें दिया गया नया कार्ड ढेर के ऊपर जोड़ दिया गया हो।
let stack = array![5, 9, 7, 1];
insert_top(stack, 8);
// -> [5, 9, 7, 1, 8]
2. ढेर से सबसे ऊपर वाला कार्ड हटाइए
फंक्शन remove_top_card बनाइए, जो ढेर की एक ऐसी कॉपी लौटाता है जिसमें से सबसे ऊपर वाला कार्ड हटा दिया गया हो।
अगर दिया गया ढेर खाली हो, तो आपको मूल ढेर बिना किसी बदलाव के ही लौटाना है।
let stack = array![3, 2, 6, 4, 8];
remove_top_card(stack);
// -> [3, 2, 6, 4]
3. ढेर के नीचे एक कार्ड डालिए
फंक्शन insert_bottom बनाइए, जो ढेर की एक कॉपी लौटाता है जिसमें दिया गया नया कार्ड ढेर के नीचे जोड़ दिया गया हो।
let stack = array![5, 9, 7, 1];
insert_bottom(stack, 8);
// -> [8, 5, 9, 7, 1]
4. ढेर के नीचे से एक कार्ड हटाइए
फंक्शन remove_bottom_card बनाइए, जो ढेर की एक ऐसी कॉपी लौटाता है जिसमें से सबसे नीचे वाला कार्ड हटा दिया गया हो।
अगर दिया गया ढेर खाली हो, तो आपको मूल ढेर बिना किसी बदलाव के ही लौटाना है।
let stack = array![8, 5, 9, 7, 1];
remove_bottom_card(stack);
// -> [5, 9, 7, 1]
5. ढेर का आकार जाँचिए
फंक्शन check_size_of_stack बनाइए, जो जाँचता है कि ढेर का आकार दिए गए stack_size के बराबर है या नहीं।
let stack = array![3, 2, 6, 4, 8];
check_size_of_stack(stack, 4);
// -> false
Cairo में ऐरे के साथ काम करना दूसरी प्रोग्रामिंग भाषाओं की तुलना में उतना सीधा क्यों नहीं है, इसे समझने के लिए एक बात याद रखना मददगार होता है: Cairo एक अपरिवर्तनीय मेमोरी मॉडल पर काम करता है। इसका मतलब है कि एक बार किसी मेमोरी सेल में लिख दिया जाए, तो उस पर दोबारा कभी नहीं लिखा जा सकता, सिर्फ पढ़ा जा सकता है।
यह भाषा इस फीचर को थोड़ा छिपा देती है, जिससे डेवलपर अपने वेरिएबलो को घोषित और इस्तेमाल ऐसे कर पाते हैं जैसे वे परिवर्तनीय हों।
हालाँकि इससे कोड लिखना थोड़ा मुश्किल हो जाता है, खासकर ऐसा कोड जो Array टाइप का इस्तेमाल करता है (ByteArray भी, जो अंदर से बाइट्स का ऐरे है)। लेकिन इसी वजह से ऐसे सिद्ध करने योग्य प्रोग्राम लिखे जा सकते हैं, जिन्हें अविश्वसनीय मशीनों पर भी भरोसे के साथ चलाया जा सकता है। इससे यह समझौता पूरी तरह फायदेमंद साबित होता है।
सीखने का अभ्यास
