מאַקסימום עריי פון צוויי געגעבן ערייז בעכעסקעם דער זעלביקער


שוועריקייט לעוועל מיטל
אָפט געבעטן אין אַקסענטורע אַמאַזאָן דעליווערי פאַקסעט פאָורקיטעס OYO רומז פּובליסיס סאַפּיענט זאָהאָ
מענגע האַש

רעכן מיר האָבן צוויי ינטאַדזשערז מענגע פון זעלביקער גרייס ען. ביידע ערייז קענען אויך אַנטהאַלטן פּראָסט נומערן. די פּראָבלעם ויסזאָגונג איז בארעכטיגט צו פאָרשטעלן די ריזאַלטאַנט מענגע וואָס כּולל די 'n' מאַקסימום וואַלועס פון ביידע ערייז. דער ערשטער מענגע זאָל זיין פּרייאָראַטייזד (עלעמענטן פון דער ערשטער מענגע זאָל דערשייַנען ערשטער אין פּראָדוקציע). דער רעזולטאַט מענגע וואָלט זיין מאַקסימום עלעמענטן פֿון ביידע געגעבן ערייז, אָבער פּראָסט עלעמענטן זאָל קומען אַמאָל און פּרייאָראַטייז די מענגע.

בייַשפּיל

ינפּוט:

int arr1 [] = {3,7,9,1,4}

int arr2 [] = {2,8,6,5,3}

אָוטפּוט:

{7, 9, 8, 6, 5}

דערקלערונג:

ווי 7, 9 זענען די עלעמענטן אין דער ערשטער מענגע, אַזוי אַז עס קומט ערשטער אין די פּראָדוקציע.

ינפּוט:

int arr1 [] = {9,3,2}

int arr2 [] = {6,4,1}

אָוטפּוט:

{9, 6, 4}

אַלגערידאַם פֿאַר מאַקסימום עריי פֿון צוויי געגעבן ערייז בעכעסקעם דער זעלביקער

  1. גער ביידע די ערייז אין די וועקטאָר.
  2. סאָרט ביידע וועקטערז אין אַ ניט-אַסענדינג סיקוואַנס.
  3. דורכגיין ביידע וועקטאָרס סיימאַלטייניאַסלי, און פּוש 'n' ביגער וואַלועס פון ביידע וועקטאָרס אין די מאַפּע צוזאמען מיט די אָפטקייט פון די עלעמענט.
  4. שאַפֿן אַ נייַע וועקטאָר "רעזולטאַט".
  5. קאָנטראָלירן צי עס איז אַ פּראָסט עלעמענט אין אַ מאַפּע און אויך אין אַ מענגע ערשטער, לייגן דעם עלעמענט אין דער פּראָדוקציע וועקטאָר.
  6. קאָנטראָלירן אויב עס איז אַ פּראָסט עלעמענט אין אַ מאַפּע און אויך אין רגע רגע, סעלעקטירן די וועמענס אָפטקייַט איז 1 און לייג זיי צו די פּראָדוקציע וועקטאָר.
  7. דרוקן די ריזאַלטיד וועקטאָר "רעזולטאַט".

דערקלערונג

קאָנווערטינג ביידע ערייז אין די וועקטאָר און סאָרט זיי אין דיקריסינג סדר. מיט דעם, מיר קענען באַקומען די וואַלועס פון ביידע ערייז אין די וועקטאָר, און מיר האָבן ביגער נומערן ערשטער אין אַ סיקוואַנס אין ביידע וועקטאָרס. אַזוי מיר קענען קלייַבן 'n' מאַקסימום נומער פון ביידע ערייז.

צו האַנדלען מיט די פאַל פון פּראָסט עלעמענטן וואָס מיר וועלן צו טאָן איז קאַמפּערד סיימאַלטייניאַסלי די וועקטאָרס און פּיקינג די מאַקסימום פון ביידע ערייז און שטעלן עס אין די מאַפּע מיט זייער אָפטקייַט. מיט דעם מיר קענען האַלטן אַן אויג אויב עס קענען ווי געוויינטלעך עלעמענטן, מיר וועלן זיין מאַקסימום עלעמענטן אין די מאַפּע. אויב מיר געפֿונען איין עלעמענט מער ווי איין מאָל, מיר נאָר פאַרגרעסערן זייער אָפטקייַט און זיי קענען ניט זיין גערעכנט ווי אַן עקסטרע עלעמענט אין אַ מאַפּע, זיי וועלן זיין אנגעצייכנט ווי אָפטקייַט 2, 3 אָדער מער .. אַזוי, אין שפּעטער טראַווערסאַל, מיר קענען איגנאָרירן עס און קענען פּרייאָראַטייז דער ערשטער מענגע.

מיר וועלן דורכפאָר ביידע די ערייז און די מאַפּע. ערשטער, מיר דאַרפֿן צו פאָרן די ערשטע מענגע מיט די מאַפּע. דערנאָך מיר וועלן דורכגיין די רגע מענגע ווייַל דער פּראָסט עלעמענט קען אויך זיין סטאָרד אין די ריזאַלטאַנט. אַזוי, צוזאַמען מיט דער פּראָסט ווערט פון די רגע מענגע און אַ מאַפּע, מיר וועלן קאָנטראָלירן אויב דער עלעמענט האט אַ אָפטקייַט פון 1 אין דער מאַפּע , דעמאָלט נאָר מיר וועלן זיין פּושינג עס אין די ריזאַלטיד וועקטאָר. און לעסאָף, דרוק דעם וועקטאָר.

ימפּלעמענטאַטיאָן

C ++ פּראָגראַם פֿאַר מאַקסימום עריי פֿון צוויי געגעבן ערייז בעכעסקעם סדר זעלביקער

#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]

קאַמפּלעקסיטי אַנאַליסיס פֿאַר מאַקסימום עריי פֿון צוויי געגעבן ערייז בעכעסקעם דער זעלביקער

צייט קאַמפּלעקסיטי

אָ (n קלאָץ n) ווו “N” איז די לענג פון ערייז.

ספעיס קאַמפּלעקסיטי

אָ (N) ווו “N” איז די לענג פון ערייז.