क्या सभी सम संख्याओं को खोजने और उन सभी को सदिश के अंत तक ले जाने का कोई आसान तरीका है? आदेश कोई मायने नहीं रखता, केवल इतना मायने रखता है कि शाम को अंत तक ले जाया गया। हालांकि, यह अच्छा होगा यदि आदेश संरक्षित किया गया था।

उदाहरण के लिए: [1, 2, 3, 4, 5] => [1, 3, 5, 2, 4]

मुझे हस्ताक्षर pub fn move_by_filter(nums: &mut Vec<i32>) चाहिए।

मैंने वेक्टर स्लाइस को फ़िल्टर और संयोजित करने का प्रयास किया, लेकिन मैं सरणी स्लाइस के संयोजन की समस्या में भाग रहा हूं:

let evens = nums.iter().filter(|&&i| i % 2 == 0).collect::<Vec<_>>();

let odds = nums.iter().filter(|&&i| i % 2 != 0).collect::<Vec<_>>();

// then I want to do something like: nums = odds.push(evens)

यह उन्हें वेक्टर के अंत तक push नहीं करता है।

मुझे यकीन नहीं है कि यह सबसे अच्छा तरीका है क्योंकि मुझे दो बार iter() का उपयोग करना है (जो कि ओ (एन) + ओ (एन) है, लेकिन यदि संभव हो तो मैं इसे एक ऑपरेशन में करना चाहता हूं)

1
codingdraculasbrain 6 अप्रैल 2020, 20:54

1 उत्तर

सबसे बढ़िया उत्तर

एक कस्टम सॉर्ट कुंजी के साथ वेक्टर को सॉर्ट करना सबसे आसान उपाय है:

pub fn sort_by_parity(nums: &mut [i32]) {
    nums.sort_by_key(|&x| x % 2 == 0);
}

रस्ट का मानक सॉर्ट एल्गोरिथ्म स्थिर है, इसलिए यह विषम और सम संख्याओं के मूल क्रम को बनाए रखेगा।

सॉर्ट कीज़ बनाने के लिए पास किया गया क्लोजर विषम संख्याओं के लिए false और सम संख्याओं के लिए true का मूल्यांकन करता है। यह सुनिश्चित करता है कि सभी विषम संख्याओं को सम संख्याओं से पहले क्रमबद्ध किया जाता है।

एक वेक्टर के लिए एक परिवर्तनीय संदर्भ को स्वीकार करने के बजाय, यह फ़ंक्शन एक परिवर्तनीय टुकड़ा संदर्भ स्वीकार करता है, जो अधिक सामान्य है।

इस दृष्टिकोण का रनटाइम ओ (एन लॉग एन) है, जो इन-प्लेस विभाजन के लिए इष्टतम नहीं है। आप रैखिक रनटाइम प्राप्त कर सकते हैं, ओ (एन), उदा। partition() पद्धति का उपयोग करके :

pub fn partition_by_parity(nums: &mut [i32]) {
    let (even, odd): (Vec<_>, Vec<_>) = nums.iter().partition(|&x| x % 2 == 0);
    nums[..odd.len()].copy_from_slice(&odd);
    nums[odd.len()..].copy_from_slice(&even);
}

दो दृष्टिकोणों के बीच रनटाइम अंतर व्यवहार में मायने नहीं रखता है।

यदि आपको विषम और सम तत्वों के मूल क्रम को संरक्षित करने की आवश्यकता नहीं है, तो आप अतिरिक्त बफर की आवश्यकता के बिना, स्लाइस को रैखिक समय में विभाजित कर सकते हैं। रस्ट नाइटली अस्थिर partition_in_place() इस उद्देश्य के लिए विधि, लेकिन स्वयं को लागू करना बहुत कठिन नहीं है - यह मूल रूप से Quicksort में विभाजन चरण है।

5
Sven Marnach 7 अप्रैल 2020, 16:00