LeetCode पर Rust: समस्याएँ हल करें और कौशल बढ़ाएँ

LeetCode पर Rust: Python से सिस्टम सोच की ओर कदम

अगर आप PythonLib पर आए हैं, तो शायद आप Python से परिचित हैं। आप एक लाइन में छोटे-छोटे समाधान लिख सकते हैं और डायनामिक टाइपिंग को सामान्य मानते हैं। लेकिन दुनिया बदल रही है। अब टॉप कंपनियों (और उनके अलावा भी) में इंटरव्यू में Rust में कोड लिखने को कहा जाता है। क्यों? क्योंकि Rust एक ऐसी भाषा है जो C की गति को मेमोरी सुरक्षा के साथ जोड़ती है, और LeetCode इस कौशल को निखारने के लिए एकदम सही जगह है।

इस लेख में हम सिर्फ सिंटैक्स पर नहीं चलेंगे। हम देखेंगे कि एल्गोरिदमिक समस्याओं को हल करते समय Rust की सोच में कैसे ढलें, कौन से डेटा स्ट्रक्चर का उपयोग करें, और borrow checker में कैसे न फँसें। चलिए शुरू करते हैं!

LeetCode पर Rust: चुनौती और फायदा क्यों?

LeetCode पर ज़्यादातर समाधान Python या Java में लिखे जाते हैं। Rust आपको मेमोरी, ओनरशिप और लाइफटाइम के बारे में सोचने पर मजबूर करता है। यह मुश्किल लगता है, लेकिन यही आपको एक बेहतर इंजीनियर बनाता है। Rust में समस्याएँ हल करके आप अपने आप सीखते हैं:

\n
• ओनरशिप सिस्टम (Ownership) — भाषा की मुख्य विशेषता।
\n
• बॉरोइंग (Borrowing) और म्यूटेबल/इम्यूटेबल रेफरेंस।
\n
• कुशल इटरेटर बिना अनावश्यक एलोकेशन के।
\n
• Option और Result के साथ काम करना, एक्सेप्शन के बजाय।
\n

अगर आप Python से आए हैं, तो पहले 10 समस्याएँ आपको यातना जैसी लगेंगी। लेकिन जब आप समझ जाएँगे कि कंपाइलर आपको null pointer और डेटा रेस से कैसे बचाता है, तो आप इस भाषा से प्यार करने लगेंगे।

शुरू करने से पहले क्या सीखें?

समस्याओं में कूदने से पहले, आइए टूलकिट समझ लें। इसके बिना आप C++ जैसा कोड मैक्रोज़ के साथ लिखेंगे — अकुशल और दर्दनाक।

1. इटरेटर और क्लोज़र (Closures)

Rust में इटरेटर सिर्फ for लूप नहीं हैं। यह एक शक्तिशाली फंक्शनल टूल है। for i in 0..vec.len() लिखने के बजाय, .iter(), .map(), .filter(), .fold() का उपयोग करना सीखें।

// Python: [x*2 for x in list if x > 0]\n// Rust:\nlet result: Vec<i32> = list.iter()\n    .filter(|&x| *x > 0)\n    .map(|x| x * 2)\n    .collect();

यह कोड न सिर्फ छोटा है, बल्कि तेज़ भी चलता है, क्योंकि इटरेटर आलसी (lazy) होते हैं और कंपाइलर उन्हें एक लीनियर लूप में ऑप्टिमाइज़ करता है।

2. HashMap और BTreeMap

फ्रीक्वेंसी गिनने वाली समस्याओं (जैसे "Two Sum" या "Group Anagrams") के लिए HashMap आपका सबसे अच्छा दोस्त है। लेकिन याद रखें: Rust में HashMap में इन्सर्ट करने के लिए की पर ओनरशिप चाहिए। अगर आप &str का उपयोग कर रहे हैं, तो आपको स्ट्रिंग को क्लोन करना होगा या String का उपयोग करना होगा।

use std::collections::HashMap;\n\nfn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {\n    let mut map = HashMap::new();\n    for (i, &num) in nums.iter().enumerate() {\n        let complement = target - num;\n        if let Some(&j) = map.get(&complement) {\n            return vec![j as i32, i as i32];\n        }\n        map.insert(num, i);\n    }\n    vec![]\n}

ध्यान दें: enumerate() एक टपल (usize, &i32) लौटाता है। हम &num का उपयोग करके रेफरेंस को डीरेफरेंस करते हैं।

3. Vec और स्लाइस

Vec एक डायनामिक ऐरे है। लेकिन LeetCode की समस्याओं में अक्सर सब-ऐरे के साथ काम करना होता है। इसके लिए स्लाइस &[T] का उपयोग करें। ये कॉपी नहीं करते और ऐरे के एक हिस्से को फंक्शन में पास करने देते हैं।

fn max_subarray_sum(arr: &[i32]) -> i32 {\n    let mut max_ending = arr[0];\n    let mut max_so_far = arr[0];\n    for &x in arr[1..].iter() {\n        max_ending = std::cmp::max(x, max_ending + x);\n        max_so_far = std::cmp::max(max_so_far, max_ending);\n    }\n    max_so_far\n}

शीर्ष 5 सामान्य गलतियाँ