ਪੈਰਿਟੀ 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 ਲੀਟਕੋਡ ਸਲਿ .ਸ਼ਨ ਦੁਆਰਾ ਸੌਰਟ ਐਰੇ ਲਈ ਪਹੁੰਚ

ਇਸ ਸਮੱਸਿਆ ਦਾ ਪਹਿਲਾ ਅਤੇ ਮੁ approachਲਾ ਪਹੁੰਚ ਇਕ ਨਵੀਂ ਐਰੇ ਬਣਾਉਣਾ ਅਤੇ ਫਿਰ ਪੁਰਾਣੀ ਐਰੇ ਨੂੰ ਟ੍ਰੈੱਸ ਕਰਨਾ ਹੈ. ਜਦੋਂ ਅਸੀਂ ਇਕ ਤੱਤ ਦਾ ਸਾਹਮਣਾ ਕਰਦੇ ਹਾਂ ਤਦ ਇਸ ਨੂੰ ਨਵੀਂ ਐਰੇ ਦੀ ਸਮਾਨ ਸਥਿਤੀ ਵਿਚ ਪਾ ਦਿੰਦੇ ਹਾਂ ਅਤੇ ਜਦੋਂ ਅਸੀਂ ਇਕ ਅਜੀਬ ਤੱਤ ਦਾ ਸਾਹਮਣਾ ਕਰਦੇ ਹਾਂ ਤਦ ਇਸਨੂੰ ਨਵੀਂ ਐਰੇ ਦੀ ਅਜੀਬ ਸਥਿਤੀ ਵਿਚ ਪਾ ਦਿੰਦੇ ਹਾਂ. ਇਹ ਪਹੁੰਚ ਅਤਿਰਿਕਤ ਜਗ੍ਹਾ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ ਅਤੇ ਅਸੀਂ ਜਗ੍ਹਾ ਪੁਨਰ ਵਿਵਸਥਾ ਵਿੱਚ ਆਪਣੇ ਤਰਕ ਨੂੰ ਸੁਧਾਰ ਸਕਦੇ ਹਾਂ.

ਪੈਰਿਟੀ II ਲੈਟਕੋਡ ਸਲਿ .ਸ਼ਨ ਦੁਆਰਾ ਐਰੇ ਨੂੰ ਕ੍ਰਮਬੱਧ ਕਰੋ

ਵਿਚਾਰ ਇਹ ਹੈ ਕਿ ਜੇ ਅਸੀਂ ਸਾਰੇ ਵੀ ਤੱਤ ਨੂੰ ਇਕੋ ਸਥਿਤੀ ਵਿਚ ਰੱਖੀਏ ਤਾਂ ਅਜੀਬ ਤੱਤ ਆਪਣੇ ਆਪ ਇਕ ਅਜੀਬ ਸਥਿਤੀ ਤੇ ਆ ਜਾਣਗੇ. ਇਸ ਲਈ ਸਾਨੂੰ ਸਿਰਫ ਇਸ ਗੱਲ 'ਤੇ ਧਿਆਨ ਕੇਂਦ੍ਰਤ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ ਕਿ ਕਿਵੇਂ ਸਮਾਨ ਸਥਿਤੀ' ਤੇ ਵੀ ਤੱਤ ਲਗਾਏ ਜਾਣ. ਅਸੀਂ ਇਨ੍ਹਾਂ ਕਦਮਾਂ ਦੀ ਪਾਲਣਾ ਕਰਾਂਗੇ:

  1. ਵੇਰੀਏਬਲ i ਨੂੰ 0 ਅਤੇ ਜੇ ਨਾਲ 1 ਦੇ ਨਾਲ ਅਰੰਭ ਕਰੋ. ਇੱਥੇ ਮੈਂ ਸਿਰਫ ਇੱਥੋਂ ਤੱਕ ਦੀ ਯਾਤਰਾ ਕਰਾਂਗਾ ਇਸ ਲਈ ਅਸੀਂ ਇਸਦੇ ਮੁੱਲ ਨੂੰ ਹਰ ਵਾਰ 2 ਵਧਾਵਾਂਗੇ ਅਤੇ ਜੇ ਸਿਰਫ ਅਜੀਬ ਸਥਿਤੀ ਦੀ ਯਾਤਰਾ ਕਰਾਂਗੇ ਤਾਂ ਅਸੀਂ ਹਰ ਵਾਰ ਇਸਦੇ ਮੁੱਲ ਨੂੰ 2 ਵਧਾਵਾਂਗੇ.
  2. ਜੇ ਸਮਾਨਤਾ [i] ਅਜੀਬ ਹੈ ਤਾਂ ਅਸੀਂ ਏਜੇਜ ਲੱਭਾਂਗੇ ਕਿ ਕਿਸ ਲਈ ਪੈਰਿਟੀ [ਜੇ] ਇਕਸਾਰ ਹੈ ਅਤੇ ਫਿਰ ਅਸੀਂ ਤੱਤ i ਅਤੇ j ਤੇ ਤਬਦੀਲ ਕਰਾਂਗੇ.
  3. ਅਸੀਂ ਇਹ ਪੜਾਅ ਉਦੋਂ ਤਕ ਕਰਾਂਗੇ ਜਦੋਂ ਤਕ i ਦੀ ਕੀਮਤ ਪੈਰੀਟੀ ਐਰੇ ਦੀ ਲੰਬਾਈ ਤੋਂ ਘੱਟ ਨਹੀਂ ਹੁੰਦੀ.
  4. ਪੈਰਿਟੀ ਐਰੇ ਵਾਪਸ ਕਰੋ.

ਲਾਗੂ

ਪੈਰਾਟੀ II ਦੁਆਰਾ ਕ੍ਰਮਬੱਧ ਐਰੇ ਲਈ C ++ ਕੋਡ

#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 ਲੀਟਕੋਡ ਸਲਿ .ਸ਼ਨ ਦੁਆਰਾ ਲੜੀਬੱਧ ਐਰੇ ਦਾ ਗੁੰਝਲਦਾਰਤਾ ਵਿਸ਼ਲੇਸ਼ਣ

ਸਮੇਂ ਦੀ ਜਟਿਲਤਾ

ਉਪਰੋਕਤ ਕੋਡ ਦੀ ਸਮੇਂ ਦੀ ਗੁੰਝਲਤਾ ਹੈ ਹੇ (n) ਕਿਉਂਕਿ ਅਸੀਂ ਸਿਰਫ ਇਕ ਵਾਰ ਪੈਰਿਟੀ ਐਰੇ ਨੂੰ ਪਾਰ ਕਰ ਰਹੇ ਹਾਂ. ਇੱਥੇ n ਪੈਰਿਟੀ ਐਰੇ ਦੀ ਲੰਬਾਈ ਹੈ.

ਸਪੇਸ ਦੀ ਜਟਿਲਤਾ

ਉਪਰੋਕਤ ਕੋਡ ਦੀ ਸਪੇਸ ਗੁੰਝਲਤਾ ਹੈ ਓ (1) ਕਿਉਂਕਿ ਅਸੀਂ ਜਵਾਬ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਸਿਰਫ ਇੱਕ ਪਰਿਵਰਤਨ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹਾਂ.

ਹਵਾਲੇ