पॅरिटि II लेटकोड सोल्यूशनद्वारे अ‍ॅरेची क्रमवारी लावा


अडचण पातळी सोपे
वारंवार विचारले ऍमेझॉन
अरे वर्गीकरण

समस्या विधान

समस्येमध्ये ”अ‍ॅरे द्वारे क्रमवारी लावा समता II, ”आम्हाला सर्व घटक सकारात्मक पूर्णांक आहेत. अ‍ॅरेमध्ये घटकांची समान संख्या आहे. अ‍ॅरेमध्ये समान आणि विषम घटकांची समान संख्या आहे.

अ‍ॅरेचे घटक अशा रीतीने पुनर्रचना करणे हे आहे की जेव्हा पॅरिटी [i] मध्ये सम घटक असतात जेव्हा मी नसतो तरीही पॅरिटी [i] मध्ये एक विचित्र घटक असणे आवश्यक आहे आणि नंतर नवीन अ‍ॅरे परत करणे.

उदाहरण

parity=[1,2,3,4]
[2,1,4,3]

स्पष्टीकरण:  अट पूर्ण करणारे सर्व संभाव्य अ‍ॅरे हे आहेत: [2,1,4,3], [2,3,4,1], [4,1,2,3], [4,3,2,1]. या अ‍ॅरेपैकी कोणीही योग्य उत्तर आहे.

पॅराटी II लीटकोड सोल्यूशनद्वारे अ‍ॅरेसाठी क्रमवारी लावणे

या समस्येचा पहिला आणि मूळ दृष्टीकोन नवीन अ‍ॅरे तयार करणे आणि नंतर जुन्या अ‍ॅरेचा शोध घेणे आहे. जेव्हा आपल्याला एखादी समकक्ष वस्तू आढळल्यास ती नवीन अ‍ॅरेच्या समान स्थितीत ठेवते आणि जेव्हा आपल्याला एखादा विषम घटक आढळतो तेव्हा त्यास नवीन अ‍ॅरेच्या विचित्र स्थितीत ठेवतो. हा दृष्टिकोन अतिरिक्त जागेचा वापर करतो आणि आम्ही स्थान पुनर्रचना करून आमचे तर्कशास्त्र सुधारू शकतो.

पॅरिटि II लेटकोड सोल्यूशनद्वारे अ‍ॅरेची क्रमवारी लावा

कल्पना आहे की जर आपण सर्व समान घटकांना सम स्थितीत ठेवले तर विषम घटक आपोआप विषम अवस्थेत येतील. तर आपल्याकडे फक्त सम घटकांवर कसे ठेवले पाहिजे यावर लक्ष केंद्रित करणे आवश्यक आहे. आम्ही या चरणांचे अनुसरण करू:

  1. व्हेरिएबल i सह 0 आणि j 1 सह आरंभ करा. येथे मी केवळ समान स्थितीत प्रवास करू जेणेकरून आम्ही प्रत्येक वेळी त्याचे मूल्य 2 ने वाढवू आणि जे केवळ विचित्र स्थितीत प्रवास करेल म्हणून आम्ही प्रत्येक वेळी त्याचे मूल्य 2 वाढवू.
  2. जर समता [i] विषम असेल तर आम्हाला अज आढळेल की कोणत्या समतेसाठी [जे] सम आहे आणि नंतर आम्ही आय आणि जे येथे घटक स्वॅप करू.
  3. I ची व्हॅल्यू पॅरिटी अ‍ॅरेच्या लांबीपेक्षा लहान होईपर्यंत आम्ही हे चरण करू.
  4. समता अ‍ॅरे परत करा.

अंमलबजावणी

पॅराटी II द्वारे क्रमवारी लावलेल्या अ‍ॅरेसाठी सी ++ कोड

#include <bits/stdc++.h> 
using namespace std; 
    vector<int> sortArrayByParityII(vector<int>& A) {
        int n =A.size();
        int j=1;
         for (int i = 0; i < n; i += 2)
            if (A[i] % 2 == 1) {
                while (A[j] % 2 == 1)
                    j += 2;
                swap(A[i],A[j]); 
            }

        return A;
    }
int main() 
{ 
 vector<int> arr = {1,2,3,4}; 
  vector<int>ans=sortArrayByParityII(arr); 
 for(int i=0;i<arr.size();i++)
 cout<<ans[i]<<" ";
 cout<<endl;
 return 0;
}
[2,1,4,3]

अ‍ॅरे बाय पॅरिटि II साठी जावा कोड

import java.util.Arrays; 
public class Tutorialcup {
    public static int[] sortArrayByParityII(int[] A) {
        int n =A.length;
        int j=1;
         for (int i = 0; i < n; i += 2)
            if (A[i] % 2 == 1) {
                while (A[j] % 2 == 1)
                    j += 2;
               swap(A, i, j);
                }

        return A;
    }
     private static void swap(int[] A, int i, int j) {
        int temp = A[i];
        A[i] = A[j];
        A[j] = temp;
    }
  public static void main(String[] args) {
        int [] arr = {1,2,3,4}; 
        int[]ans=sortArrayByParityII(arr); 
        System.out.println(Arrays.toString(ans));
  }
}
[2,1,4,3]

पॅराटी II लीटकोड सोल्यूशनद्वारे सॉर्ट अ‍ॅरेचे कॉम्प्लेक्सिटी एनालिसिस

वेळ गुंतागुंत

वरील कोडची वेळ जटिलता आहे O (n) कारण आम्ही फक्त एकदाच पॅरिटी अ‍ॅरेचा शोध घेत आहोत. येथे n पॅरिटि अ‍ॅरेची लांबी आहे.

जागेची जटिलता

वरील कोडची स्पेस कॉम्प्लेक्सिटी आहे ओ (1) कारण आम्ही उत्तर संग्रहित करण्यासाठी फक्त एक व्हेरिएबल वापरत आहोत.

संदर्भ