ਦੋ ਦਿੱਤੇ ਐਰੇ ਤੋਂ ਅਧਿਕਤਮ ਐਰੇ ਉਸੇ ਤਰ੍ਹਾਂ ਰੱਖਦੇ ਹੋਏ


ਮੁਸ਼ਕਲ ਪੱਧਰ ਦਰਮਿਆਨੇ
ਅਕਸਰ ਪੁੱਛਿਆ ਜਾਂਦਾ ਹੈ Accenture ਐਮਾਜ਼ਾਨ ਦਿੱਲੀ ਵਾਸੀ ਤੱਥ ਫੋਰਕਾਈਟਸ ਓਏ ਕਮਰੇ ਪਬਲਿਕਸ ਸੇਪੀਐਂਟ ਜੋਹੋ
ਅਰੇ ਹੈਸ਼

ਮੰਨ ਲਓ ਸਾਡੇ ਕੋਲ ਦੋ ਪੂਰਨ ਅੰਕ ਹਨ ਐਰੇ ਉਸੇ ਆਕਾਰ ਦੇ ਐਨ. ਦੋਵੇਂ ਐਰੇ ਵਿੱਚ ਆਮ ਨੰਬਰ ਵੀ ਹੋ ਸਕਦੇ ਹਨ. ਸਮੱਸਿਆ ਦਾ ਬਿਆਨ ਨਤੀਜਾ ਬਣਨ ਵਾਲੇ ਐਰੇ ਬਣਾਉਣ ਲਈ ਕਹਿੰਦਾ ਹੈ ਜਿਸ ਵਿਚ ਦੋਵੇਂ ਐਰੇ ਤੋਂ 'n' ਵੱਧ ਤੋਂ ਵੱਧ ਮੁੱਲ ਹੁੰਦੇ ਹਨ. ਪਹਿਲੀ ਐਰੇ ਨੂੰ ਪਹਿਲ ਦਿੱਤੀ ਜਾਣੀ ਚਾਹੀਦੀ ਹੈ (ਪਹਿਲੇ ਐਰੇ ਦੇ ਤੱਤ ਪਹਿਲਾਂ ਆਉਟਪੁੱਟ ਵਿੱਚ ਦਿਖਾਈ ਦੇਣ). ਆਉਟਪੁੱਟ ਐਰੇ ਦਿੱਤੇ ਗਏ ਦੋਵੇਂ ਐਰੇ ਵਿੱਚੋਂ ਵੱਧ ਤੋਂ ਵੱਧ ਤੱਤਾਂ ਦੀ ਹੋਵੇਗੀ ਪਰ ਆਮ ਤੱਤ ਇੱਕ ਵਾਰ ਆਉਣਾ ਚਾਹੀਦਾ ਹੈ ਅਤੇ ਪਹਿਲਾਂ ਐਰੇ ਨੂੰ ਤਰਜੀਹ ਦੇਣੀ ਚਾਹੀਦੀ ਹੈ.

ਉਦਾਹਰਨ

ਇੰਪੁੱਟ:

ਪੂਰਵ arr1 [] = {3,7,9,1,4}

ਪੂਰਵ arr2 [] = {2,8,6,5,3}

ਆਉਟਪੁੱਟ:

{7, 9, 8, 6, 5

ਸਪਸ਼ਟੀਕਰਨ:

ਜਿਵੇਂ ਕਿ 7, 9 ਪਹਿਲੇ ਐਰੇ ਵਿਚ ਐਲੀਮੈਂਟਸ ਹਨ, ਤਾਂ ਜੋ ਇਹ ਆਉਟਪੁਟ ਵਿਚ ਪਹਿਲੇ ਨੰਬਰ ਤੇ ਆਵੇ.

ਇੰਪੁੱਟ:

ਪੂਰਵ arr1 [] = {9,3,2}

ਪੂਰਵ arr2 [] = {6,4,1}

ਆਉਟਪੁੱਟ:

{9, 6, 4

ਦੋ ਦਿੱਤੇ ਗਏ ਐਰੇ ਤੋਂ ਅਧਿਕਤਮ ਐਰੇ ਲਈ ਐਲਗੋਰਿਦਮ ਉਸੇ ਤਰ੍ਹਾਂ ਦਾ ਆਦੇਸ਼ ਰੱਖਦਾ ਹੈ

  1. ਐਰੇ ਨੂੰ ਦੋਨੋ ਵਿੱਚ ਤਬਦੀਲ ਕਰੋ ਵੈਕਟਰ.
  2. ਦੋਵਾਂ ਵੈਕਟਰਾਂ ਨੂੰ ਗੈਰ-ਚੜ੍ਹਾਈ ਵਾਲੇ ਕ੍ਰਮ ਵਿੱਚ ਕ੍ਰਮਬੱਧ ਕਰੋ.
  3. ਦੋਵਾਂ ਵੈਕਟਰਾਂ ਨੂੰ ਇਕੋ ਸਮੇਂ ਪਾਰ ਕਰੋ ਅਤੇ ਤੱਤ ਦੀ ਬਾਰੰਬਾਰਤਾ ਦੇ ਨਾਲ ਦੋਨੋਂ ਵੈਕਟਰਾਂ ਦੀਆਂ ਵੱਡੀਆਂ ਕੀਮਤਾਂ ਨੂੰ ਨਕਸ਼ੇ ਵਿਚ ਧੱਕੋ.
  4. ਇੱਕ ਨਵਾਂ ਵੈਕਟਰ "ਆਉਟਪੁੱਟ" ਬਣਾਓ.
  5. ਜਾਂਚ ਕਰੋ ਕਿ ਕੀ ਇੱਕ ਵਿੱਚ ਇੱਕ ਆਮ ਤੱਤ ਹੈ ਫੋਲਡਰ ਨੂੰ ਅਤੇ ਪਹਿਲਾਂ ਐਰੇ ਵਿਚ ਵੀ, ਫਿਰ, ਐਲੀਮੈਂਟ ਨੂੰ ਆਉਟਪੁਟ ਵੈਕਟਰ ਵਿਚ ਸ਼ਾਮਲ ਕਰੋ.
  6. ਚੈੱਕ ਕਰੋ, ਜੇ ਨਕਸ਼ੇ ਵਿਚ ਅਤੇ ਆਮ ਐਰੇ ਵਿਚ ਵੀ ਇਕ ਆਮ ਤੱਤ ਹੈ, ਤਾਂ, ਉਹਨਾਂ ਦੀ ਚੋਣ ਕਰੋ ਜਿਨ੍ਹਾਂ ਦੀ ਬਾਰੰਬਾਰਤਾ 1 ਹੈ, ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਆਉਟਪੁਟ ਵੈਕਟਰ ਵਿਚ ਸ਼ਾਮਲ ਕਰੋ.
  7. ਨਤੀਜੇ ਵੈਕਟਰ "ਆਉਟਪੁੱਟ" ਪ੍ਰਿੰਟ ਕਰੋ.

ਕਥਾ

ਦੋਵਾਂ ਐਰੇ ਨੂੰ ਵੈਕਟਰ ਵਿੱਚ ਬਦਲਣਾ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਘੱਟਦੇ ਕ੍ਰਮ ਵਿੱਚ ਕ੍ਰਮਬੱਧ ਕਰਨਾ. ਇਸ ਨਾਲ, ਅਸੀਂ ਵੈਕਟਰ ਵਿਚ ਦੋਵੇਂ ਐਰੇ ਦੀਆਂ ਕਦਰਾਂ ਕੀਮਤਾਂ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹਾਂ ਅਤੇ ਸਾਡੇ ਦੋਵਾਂ ਵੈਕਟਰਾਂ ਵਿਚ ਇਕ ਲੜੀ ਵਿਚ ਪਹਿਲਾਂ ਵੱਡੀ ਸੰਖਿਆ ਹੈ. ਤਾਂ ਅਸੀਂ 'ਐਨ' ਚੁਣ ਸਕਦੇ ਹਾਂ ਵੱਧ ਤੋਂ ਵੱਧ ਗਿਣਤੀ ਦੋਵੇਂ ਐਰੇ ਤੋਂ

ਆਮ ਤੱਤ ਦੇ ਮਾਮਲੇ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਜੋ ਅਸੀਂ ਕਰਨ ਜਾ ਰਹੇ ਹਾਂ ਉਹ ਹੈ, ਇਕੋ ਸਮੇਂ ਵੈਕਟਰਾਂ ਦੀ ਤੁਲਨਾ ਕਰਨਾ ਅਤੇ ਦੋਵੇਂ ਐਰੇ ਤੋਂ ਵੱਧ ਤੋਂ ਵੱਧ ਚੁਣਨਾ, ਅਤੇ ਇਸ ਨੂੰ ਆਪਣੀ ਬਾਰੰਬਾਰਤਾ ਨਾਲ ਨਕਸ਼ੇ ਵਿਚ ਪਾਉਣਾ, ਇਸ ਨਾਲ ਅਸੀਂ ਇਕ ਅੱਖ ਬਣਾਈ ਰੱਖ ਸਕਦੇ ਹਾਂ ਜੇ ਉਥੇ ਹੋ ਸਕੇ. ਆਮ ਤੱਤ ਬਣੋ, ਅਸੀਂ ਨਕਸ਼ੇ ਵਿੱਚ n ਅਧਿਕਤਮ ਤੱਤਾਂ ਨੂੰ ਅੱਗੇ ਵਧਾ ਰਹੇ ਹੋਵਾਂਗੇ, ਜੇ ਸਾਨੂੰ ਇਕ ਤੱਤ ਇਕ ਤੋਂ ਵੱਧ ਵਾਰ ਮਿਲੇ, ਤਾਂ ਅਸੀਂ ਉਨ੍ਹਾਂ ਦੀ ਬਾਰੰਬਾਰਤਾ ਵਧਾਉਣ ਜਾ ਰਹੇ ਹਾਂ ਅਤੇ ਉਨ੍ਹਾਂ ਨੂੰ ਇਕ ਨਕਸ਼ੇ ਵਿਚ ਇਕ ਵਾਧੂ ਤੱਤ ਨਹੀਂ ਗਿਣਿਆ ਜਾਵੇਗਾ, ਉਹ ਹੋਣਗੇ ਬਾਰੰਬਾਰਤਾ 2, 3 ਜਾਂ ਇਸ ਤੋਂ ਵੱਧ ਦੇ ਰੂਪ ਵਿੱਚ ਚਿੰਨ੍ਹਿਤ ਕੀਤਾ ਗਿਆ ਹੈ .. ਇਸ ਲਈ ਬਾਅਦ ਵਿੱਚ, ਅਸੀਂ ਇਸ ਨੂੰ ਨਜ਼ਰ ਅੰਦਾਜ਼ ਕਰ ਸਕਦੇ ਹਾਂ ਅਤੇ ਪਹਿਲੇ ਐਰੇ ਨੂੰ ਤਰਜੀਹ ਦੇ ਸਕਦੇ ਹਾਂ.

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

ਲਾਗੂ

ਕ੍ਰਮਬੱਧ ਕ੍ਰਮ ਦੇ ਦੋ ਦਿੱਤੇ ਐਰੇ ਤੋਂ ਅਧਿਕਤਮ ਐਰੇ ਲਈ ਸੀ ++ ਪ੍ਰੋਗਰਾਮ

#include<iostream>
#include<unordered_map>
#include<vector>
#include<algorithm>

using namespace std;

void makeGreaterFirstArray(int A[], int B[], int n)
{
    vector<int> V1(A, A+n);
    vector<int> V2(B, B+n);
    sort(V1.begin(), V1.end(), greater<int>());
    sort(V2.begin(), V2.end(), greater<int>());

    unordered_map<int, int> MAP;
    int i = 0, j = 0;
    while (MAP.size() < n)
    {
        if (V1[i] >= V2[j])
        {
            MAP[V1[i]]++;
            i++;
        }
        else
        {
            MAP[V2[j]]++;
            j++;
        }
    }
    vector<int> output;
    for (int i = 0; i < n; i++)
        if (MAP.find(A[i]) != MAP.end())
            output.push_back(A[i]);

    for (int i = 0; i < n; i++)
        if (MAP.find(B[i]) != MAP.end() && MAP[B[i]] == 1)
            output.push_back(B[i]);

    for (int i = 0; i < n; i++)
        cout << output[i] << " ";
}
int main()
{
    int arr1[] = {3,7,9,1,4};
    int arr2[] = {2,8,6,5,3};
    int n = sizeof(arr1) / sizeof(arr1[0]);
    makeGreaterFirstArray(arr1, arr2, n);
    return 0;
}
7 9 8 6 5

ਦੋ ਦਿੱਤੇ ਐਰੇ ਤੋਂ ਅਧਿਕਤਮ ਐਰੇ ਲਈ ਜਾਵਾ ਪ੍ਰੋਗਰਾਮ, ਉਸੇ ਤਰ੍ਹਾਂ ਕੀਪਿੰਗ ਆਰਡਰ ਰੱਖਦਾ ਹੈ

import java.util.Collections;
import java.util.Vector;
import java.util.HashMap;
import java.util.Arrays;
import java.util.stream.Collectors;

class findsubarray
{
    public static void makeGreaterFirstArray(int []A, int []B, int n)
    {
        Vector<Integer> V1 = new Vector<>();
        Vector<Integer> V2 = new Vector<>();

        Integer[] I1 = Arrays.stream( A ).boxed().toArray( Integer[]::new );
        Integer[] I2 = Arrays.stream( B ).boxed().toArray( Integer[]::new );


        Collections.addAll(V1, I1);
        Collections.addAll(V2, I2);

        Collections.sort(V1, Collections.reverseOrder());
        Collections.sort(V2, Collections.reverseOrder());


        HashMap<Integer, Integer> MAP = new HashMap<Integer, Integer>();

        int i = 0, j = 0;
        while (MAP.size() < n)
        {
            if (V1.get(i) >= V2.get(j))
            {
                if(MAP.containsKey(V1.get(i)))
                {
                    MAP.put(V1.get(i), MAP.get(V1.get(i))+1);
                    i++;
                }
                else
                {
                    MAP.put(V1.get(i),1);
                    i++;
                }
            }
            else
            {
                if(MAP.containsKey(V2.get(j)))
                {
                    MAP.put(V2.get(j), MAP.get(V2.get(j))+1);
                    j++;
                }
                else
                {
                    MAP.put(V2.get(j),1);
                    j++;
                }
            }
        }
        Vector<Integer> output = new Vector<Integer>();

        for (int a = 0; a < n; a++)
            if (MAP.containsKey(A[a]))
                output.add(A[a]);

        for (int b = 0; b < n; b++)
            if (MAP.containsKey(B[b]) && MAP.get(B[b])==1)
                output.add(B[b]);


        System.out.println(output);
    }
    public static void main(String [] args)
    {
        int arr1[] = {3,7,9,1,4};
        int arr2[] = {2,8,6,5,3};
        int n = arr1.length;
        makeGreaterFirstArray(arr1, arr2, n);
    }
}
[7, 9, 8, 6, 5]

ਦੋ ਦਿੱਤੇ ਗਏ ਐਰੇ ਤੋਂ ਅਧਿਕਤਮ ਐਰੇ ਲਈ ਜਟਿਲਤਾ ਵਿਸ਼ਲੇਸ਼ਣ ਇਕੋ ਜਿਹਾ ਹੈ

ਟਾਈਮ ਜਟਿਲਤਾ

O (n ਲਾਗ n) ਜਿੱਥੇ ਕਿ “ਐਨ” ਐਰੇ ਦੀ ਲੰਬਾਈ ਹੈ.

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

ਹੇ (n) ਜਿੱਥੇ ਕਿ “ਐਨ” ਐਰੇ ਦੀ ਲੰਬਾਈ ਹੈ.