क्रोनो रियल्म्स क्रोनो चेन

use core::box::{BoxTrait};

#[derive(Copy, Drop)]
enum BinaryTree {
    Leaf: u32,
    Node: (u32, Box<BinaryTree>, Box<BinaryTree>),
}

fn main() {
    let leaf1 = BinaryTree::Leaf(1);
    let leaf2 = BinaryTree::Leaf(2);
    let node = BinaryTree::Node((3, BoxTrait::new(leaf1), BoxTrait::new(leaf2)));
    println!("{:?}", node);
}

// `Cart` is a large struct that contains a lot of information
fn pass_pointer(cart: Box<Cart>) {
    let cart = cart.unbox();
    println!("{} is shopping today and bought {} items", cart.buyer, cart.items);
}

निर्देश

Chrono Realms में Time Keepers को अक्सर सिर्फ टाइमलाइनों के पेड़ों ही नहीं, बल्कि Chrono Chains से भी काम पड़ता है। Chrono Chain जुड़े हुए TimeNodes का क्रम होता है, जिनमें हर TimeNode समय के किसी एक खास पल को दर्शाता है।

एक Chrono Chain एक के बाद एक आने वाले पलों का सीधा रास्ता होता है, जिसमें हर TimeNode अगले नोड से जुड़ता है।

जब Time Keepers को किसी खास घटनाओं के क्रम से गुज़रना होता है, तब इन Chrono Chains से बहुत मदद मिलती है, क्योंकि इनसे वे एक ही टाइमलाइन पर चल सकते हैं।

लेकिन इन Chrono Chains को, जो काफी लंबी हो सकती हैं, संभालने के लिए Time Keepers स्मार्ट पॉइंटर (Box<t>)</t> का इस्तेमाल करते हैं। इससे वे पलों के इन ऐरे को सुरक्षित तरीके से संभाल पाते हैं और उन पर एक-एक करके चल पाते हैं, जिससे मेमोरी की अनावश्यक नकल या ओवरफ्लो नहीं होता।

हर TimeNode अगले नोड का रेफरेंस अपने अंदर रखता है, जिससे एक रिकर्सिव स्ट्रक्चर बनता है।

एक शिष्य के रूप में आपको स्मार्ट पॉइंटर की मदद से एक Chrono Chain को रिकर्सिव ऐरे स्ट्रक्चर के रूप में लागू करना है।

इस अभ्यास में आप यह सब करेंगे:

1. एक रिकर्सिव ChronoChain एनम बनाइए, जो पलों के एक ऐरे को दर्शाता है।
2. रिकर्सिव नोड संग्रहीत करने के लिए Box<T> स्मार्ट पॉइंटर का इस्तेमाल कीजिए।
3. u32 वैल्यू के एक ऐरे से एक ChronoChain बनाने वाला फंक्शन लागू कीजिए।
4. ChronoChain पर एक-एक करके चलकर उसमें रखी वैल्यू का जोड़ निकालने वाला फंक्शन लागू कीजिए।

1. रिकर्सिव ChronoChain एनम को परिभाषित कीजिए

दो वेरिएंट वाला एक रिकर्सिव एनम ChronoChain बनाइए:

• End: ऐरे के अंत को दर्शाता है।
• Link: इसमें एक u32 वैल्यू और चेन में अगले नोड का बॉक्स में रखा हुआ रेफरेंस रहता है।

2. ChronoChain बनाने वाला फंक्शन बनाइए

एक फंक्शन ChronoChain::build लिखिए, जो u32 वैल्यू का एक ऐरे लेता है और एक ChronoChain लौटाता है। यह फंक्शन स्मार्ट पॉइंटर की मदद से वैल्यू को एक के बाद एक जोड़ता जाता है।

3. जोड़ वाला फंक्शन लागू कीजिए

एक फंक्शन ChronoChain::sum लिखिए, जो ChronoChain पर रिकर्सिव तरीके से एक-एक करके चलता है और सभी नोड की वैल्यू का जोड़ निकालता है।

इस्तेमाल का उदाहरण

fn main() {
    // Create a ChronoChain from an array of values
    let chrono_chain = ChronoChain::build(array![10, 20, 30]);

    // Sum the values in the ChronoChain
    let total_sum = chrono_chain.sum();

    println!("Total Time Power: {}", total_sum);
}