Givenર્ડર એ જ રાખીને આપેલ બે એરેમાંથી મહત્તમ એરે  


મુશ્કેલી સ્તર મધ્યમ
વારંવાર પૂછવામાં આવે છે એક્સેન્ચર એમેઝોન દિલ્હીવારી ફેક્ટસેટ ફોરકાઇટ્સ ઓયો ઓરડાઓ પબ્લિકિસ સેપિયન્ટ ઝોહો
અરે હેશ

ધારો કે આપણી પાસે બે પૂર્ણાંકો છે એરે સમાન કદ એન. બંને એરેમાં સામાન્ય સંખ્યાઓ પણ શામેલ હોઈ શકે છે. સમસ્યાનું નિવેદન પરિણામ એરે બનાવવાનું કહે છે જેમાં બંને એરેમાંથી મહત્તમ મૂલ્યો શામેલ છે. પ્રથમ એરેને પ્રાધાન્ય આપવું જોઈએ (પ્રથમ એરેના ઘટકો આઉટપુટમાં પ્રથમ દેખાવા જોઈએ). આપેલ બંને એરેમાંથી આઉટપુટ એરે મહત્તમ તત્વોનો હશે પરંતુ સામાન્ય તત્વો એકવાર આવવા જોઈએ અને પહેલા એરેને પ્રાધાન્ય આપવું જોઈએ.

ઉદાહરણ  

ઇનપુટ:

પૂર્ણાંક એઆર 1 [] = {3,7,9,1,4}

પૂર્ણાંક એઆર 2 [] = {2,8,6,5,3}

આઉટપુટ:

{7, 9, 8, 6, 5

સમજૂતી:

7, 9 એ પ્રથમ એરેમાં તત્વો છે, જેથી તે આઉટપુટમાં પ્રથમ આવે.

ઇનપુટ:

પૂર્ણાંક એઆર 1 [] = {9,3,2}

પૂર્ણાંક એઆર 2 [] = {6,4,1}

આઉટપુટ:

{9, 6, 4

Givenર્ડર એ જ રાખવા બે આપેલ એરેમાંથી મહત્તમ એરે માટે અલ્ગોરિધમનો  

  1. બંને એરેને રૂપાંતરિત કરો વેક્ટર.
  2. બંને ચિકિત્સકોને બિન-ચડતા ક્રમમાં સortર્ટ કરો.
  3. બંને વેક્ટર્સને એક સાથે પસાર કરો, અને તત્વની આવર્તન સાથે નકશામાં બંને વેક્ટરના મોટા મૂલ્યોને 'એન' નાખો.
  4. નવું વેક્ટર “આઉટપુટ” બનાવો.
  5. એમાં કોઈ સામાન્ય તત્વ છે કે કેમ તે તપાસો નકશો અને એરેમાં પણ પહેલા, પછી, તે તત્વને આઉટપુટ વેક્ટરમાં ઉમેરો.
  6. તપાસો, જો નકશામાં અને જો એરેમાં પણ સામાન્ય તત્વ છે, તો, જેમની આવર્તન 1 છે તે પસંદ કરો અને તેમને આઉટપુટ વેક્ટરમાં ઉમેરો.
  7. પરિણામ વેક્ટર "આઉટપુટ" છાપો.
આ પણ જુઓ
ન્યૂનતમ કૌંસ રિવર્સલ્સ

સમજૂતી  

બંને એરેને વેક્ટરમાં ફેરવવું અને તેને ઘટતા ક્રમમાં ગોઠવો. આની મદદથી, આપણે વેક્ટરમાં બંને એરેની કિંમતો મેળવી શકીએ છીએ અને આપણી પાસે બંને વેક્ટરના ક્રમમાં પ્રથમ મોટી સંખ્યા છે. તેથી, આપણે 'એન' પસંદ કરી શકીએ મહત્તમ સંખ્યા એરે બંને માંથી.

આપણે શું કરવા જઈ રહ્યા છીએ તે સામાન્ય તત્વોના કેસને હેન્ડલ કરવા માટે, એક સાથે વેક્ટરની તુલના કરવી અને એરે બંનેમાંથી મહત્તમ ચૂંટવું, અને તેને તેમની આવર્તન સાથે નકશામાં મૂકવું, આ સાથે આપણે જો ત્યાં નજર રાખી શકીએ તો સામાન્ય તત્વો બનો, અમે નકશામાં n મહત્તમ તત્વોને દબાણ કરીશું, જો અમને એક કરતા વધારે તત્વો મળી આવે, તો અમે ફક્ત તેમની આવર્તન વધારીશું અને તેઓ નકશામાં વધારાના તત્વ તરીકે ગણાશે નહીં, તેઓ હશે ફ્રીક્વન્સી 2, 3 અથવા તેથી વધુ તરીકે ચિહ્નિત થયેલ છે .. તેથી, પાછળથી ટ્રversવર્સલમાં, આપણે તેને અવગણી શકીએ છીએ અને પ્રથમ એરેને અગ્રતા આપી શકીએ છીએ.

અમે એરે અને નકશા બંનેને પસાર કરીશું. પ્રથમ, આપણે નકશા સાથે પ્રથમ એરેને પસાર કરવાની જરૂર છે, જો નકશામાં તેમજ એરેમાં કોઈ સામાન્ય ઘટકો જોવા મળે છે, તો આપણે તેને આઉટપુટ વેક્ટરમાં દબાણ કરવાની જરૂર છે, જેને આપણે પરિણામે બનાવ્યું છે. પછી આપણે બીજા એરેને પસાર કરીશું કારણ કે સામાન્ય ઘટક પણ પરિણામમાં સંગ્રહિત થઈ શકે છે, તેથી અહીં બીજા એરે અને નકશામાંથી સામાન્ય મૂલ્યની સાથે, અમે તપાસ કરીશું કે નકશામાં તે તત્વની આવર્તન 1 છે કે કેમ. , તો જ આપણે તેને પરિણામી વેક્ટરમાં દબાણ કરીશું. અને અંતે, તે વેક્ટરને છાપો.

આ પણ જુઓ
એરેમાં મહત્તમ સતત નંબર્સ હાજર છે

અમલીકરણ  

Givenર્ડર એ જ રાખવા બે આપેલ એરેમાંથી મહત્તમ એરે માટે સી ++ પ્રોગ્રામ

#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

Givenર્ડર એ જ રીતે બે આપેલ એરેમાંથી મહત્તમ એરે માટે જાવા પ્રોગ્રામ

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]

Givenર્ડર એ જ રાખીને આપેલ બે એરેમાંથી મહત્તમ એરે માટે જટિલતા વિશ્લેષણ  

સમય જટિલતા

ઓ (એન લ logગ એન) જ્યાં “એન” એરેની લંબાઈ છે.

આ પણ જુઓ
એરેમાં મહત્તમ અંતર

અવકાશ જટિલતા

ઓ (એન) જ્યાં “એન” એરેની લંબાઈ છે.