ਐਰੇ ਲੀਟਕੋਡ ਹੱਲ ਵਿੱਚ ਦੋ ਤੱਤਾਂ ਦਾ ਵੱਧ ਤੋਂ ਵੱਧ ਉਤਪਾਦ


ਮੁਸ਼ਕਲ ਪੱਧਰ ਸੌਖੀ
ਅਕਸਰ ਪੁੱਛਿਆ ਜਾਂਦਾ ਹੈ ਸੈਮਸੰਗ
ਅਰੇ

“ਇਕ ਐਰੇ ਵਿਚ ਦੋ ਤੱਤਾਂ ਦਾ ਵੱਧ ਤੋਂ ਵੱਧ ਉਤਪਾਦ” ਦੀ ਸਮੱਸਿਆ ਵਿਚ, ਸਾਡਾ ਟੀਚਾ ਦੋ ਸੂਚਕਾਂਕ ਨੂੰ ਲੱਭਣਾ ਹੈ i ਅਤੇ j ਪੂਰਨ ਅੰਕ ਦੀ ਦਿੱਤੀ ਗਈ ਐਰੇ ਵਿਚ a, ਜਿਵੇਂ ਕਿ ਉਤਪਾਦ (a [i] - 1) * (a [ਜੇ] - 1) ਵੱਧ ਤੋਂ ਵੱਧ ਹੈ. ਐਰੇ ਵਿੱਚ ਘੱਟੋ ਘੱਟ 2 ਤੱਤ ਹਨ ਅਤੇ ਸਾਰੇ ਤੱਤ ਸਕਾਰਾਤਮਕ ਹਨ. ਸਮੱਸਿਆ ਜੋ ਲੋੜੀਂਦਾ ਉਤਪਾਦ ਪੂਰਨ ਅੰਕ ਵਿੱਚ ਫਿੱਟ ਹੈ. ਸਾਨੂੰ ਅਨੁਕੂਲ ਲਈ (a [i] - 1) * (a [ਜੇ] - 1) ਦਾ ਮੁੱਲ ਪ੍ਰਿੰਟ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ i & j.

ਉਦਾਹਰਨ

a = {1 , 4 , 5 , 3 , 6 , 4}
2

ਕਥਾ

ਸਪੱਸ਼ਟ ਤੌਰ ਤੇ, 6 ਅਤੇ 5 ਸਭ ਤੋਂ ਵੱਡੀ ਅਤੇ ਦੂਜੀ ਸਭ ਤੋਂ ਵੱਡੀ ਸੰਖਿਆ ਹੈ. ਤਾਂ, ਉਤਪਾਦ = (a [i] - 1) * (ਏ [ਜੇ] - 1) = 20.

ਪਹੁੰਚ (ਛਾਂਟੀ)

ਉਤਪਾਦ: (a [i] - 1) * (a [j] - 1) ਵੱਧ ਤੋਂ ਵੱਧ ਹੋ ਜਾਏਗਾ ਜਦੋਂ ਇੱਕ [i] ਅਤੇ a [j] ਐਰੇ ਵਿੱਚ ਦੋ ਸਭ ਤੋਂ ਵੱਡੇ ਤੱਤ ਹੋਣ. ਇਸ ਦੇ ਬਜਾਏ ਦੋ ਸੂਚਕਾਂਕ i ਅਤੇ j ਨੂੰ ਲੱਭਣ ਦੀ ਬਜਾਏ ਦੋ ਸਭ ਤੋਂ ਵੱਡੇ ਤੱਤ ਹਨ, ਅਸੀਂ ਕਰ ਸਕਦੇ ਹਾਂ ਲੜੀਬੱਧ The ਐਰੇ ਚੜ੍ਹਦੇ ਕ੍ਰਮ ਵਿੱਚ. ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰੇਗਾ ਕਿ ਦੋ ਸਭ ਤੋਂ ਵੱਡੇ ਤੱਤ ਅੰਤ 'ਤੇ ਹਨ. ਇਸ ਲਈ, ਉਤਪਾਦ (a [n - 1] - 1) * (a [n - 2] - 1) ਲੋੜੀਂਦਾ ਨਤੀਜਾ ਹੋਵੇਗਾ.

ਐਲਗੋਰਿਥਮ

  1. ਐਰੇ ਨੂੰ ਸੌਰਟ ਕਰੋ
  2. ਨਤੀਜਾ ਪ੍ਰਿੰਟ ਕਰੋ: (a [n - 1] - 1) * (a [n - 2] - 1)

ਇੱਕ ਐਰੇ ਵਿੱਚ ਦੋ ਤੱਤਾਂ ਦਾ ਵੱਧ ਤੋਂ ਵੱਧ ਉਤਪਾਦ ਲੱਭਣ ਲਈ ਐਲਗੋਰਿਦਮ ਨੂੰ ਲਾਗੂ ਕਰਨਾ

ਸੀ ++ ਪ੍ਰੋਗਰਾਮ

#include <bits/stdc++.h>
using namespace std;

int maxProduct(vector <int> &a)
{
    int n = a.size();
    sort(a.begin() , a.end());
    return ((a[n - 1] - 1) * (a[n - 2] - 1));
}


int main()
{
    vector <int> a = {1 , 4 , 5 , 3 , 6 , 4};
    cout << maxProduct(a) << '\n';
}

ਜਾਵਾ ਪ੍ਰੋਗਰਾਮ

import java.util.Arrays;

class maximum_product
{
    public static void main(String args[])
    {
        int[] a = {1 , 4 , 5 , 3 , 6 , 4};
        System.out.println(maxProduct(a));
    }

    static int maxProduct(int[] a)
    {
        int n = a.length;
        Arrays.sort(a);
        return (a[n - 1] - 1) * (a[n - 2] - 1);
    }
}
20

ਇੱਕ ਐਰੇ ਵਿੱਚ ਦੋ ਤੱਤਾਂ ਦੇ ਵੱਧ ਤੋਂ ਵੱਧ ਉਤਪਾਦਾਂ ਦਾ ਪਤਾ ਲਗਾਉਣ ਦੀ ਜਟਿਲਤਾ ਵਿਸ਼ਲੇਸ਼ਣ

ਟਾਈਮ ਜਟਿਲਤਾ

ਓ (ਐਨ ਐਲ ਐਨ ਐਨ), ਐਨ = ਐਰੇ ਦਾ ਆਕਾਰ. ਅਸੀਂ ਐਰੇ ਨੂੰ ਕ੍ਰਮਬੱਧ ਕਰਦੇ ਹਾਂ ਜੋ ਕਿ O (NlogN) ਸਮਾਂ ਲੈਂਦਾ ਹੈ.

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

ਓ (1)ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਨਿਰੰਤਰ ਮੈਮੋਰੀ ਸਪੇਸ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ.

ਪਹੁੰਚ (ਅਨੁਕੂਲ)

ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਉੱਪਰ ਵਿਚਾਰਿਆ ਹੈ, ਸਾਨੂੰ ਐਰੇ ਵਿਚਲੇ ਦੋ ਸਭ ਤੋਂ ਵੱਡੇ ਤੱਤ ਲੱਭਣ ਦੀ ਜ਼ਰੂਰਤ ਹੈ. ਪੂਰੀ ਐਰੇ ਨੂੰ ਛਾਂਟ ਕੇ, ਅਸੀਂ ਜ਼ਿਆਦਾ ਲੋੜੀਂਦਾ ਕੰਮ. ਇਸ ਲਈ, ਸਧਾਰਣ ਤੁਲਨਾ ਕਰਨ ਵਾਲੇ ਕਾਰਜਾਂ ਦੁਆਰਾ ਐਰੇ ਵਿਚ ਪਹਿਲੇ ਅਤੇ ਦੂਜੇ ਸਭ ਤੋਂ ਵੱਡੇ ਤੱਤ ਨੂੰ ਲੱਭਣਾ ਅਨੁਕੂਲ ਹੈ. ਇਸ ਲਈ, ਲੋੜੀਂਦਾ ਨਤੀਜਾ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ (ਫਸਟਮੈਕਸ - 1) * (ਸੈਕਿੰਡ ਮੈਕਸ - 1).

ਐਰੇ ਲੀਟਕੋਡ ਹੱਲ ਵਿੱਚ ਦੋ ਤੱਤਾਂ ਦਾ ਵੱਧ ਤੋਂ ਵੱਧ ਉਤਪਾਦ

ਐਲਗੋਰਿਥਮ

  1. ਦੋ ਵੇਰੀਏਬਲ ਅਰੰਭ ਕਰੋ: ਪਹਿਲਾਮੈਕਸ ਅਤੇ ਸੈਕਿੰਡ ਮੈਕਸ ਜ਼ੀਰੋ ਦੇ ਤੌਰ ਤੇ (ਤਾਂ ਜੋ ਐਰੇ ਦਾ ਕੋਈ ਵੀ ਮੁੱਲ ਉਹਨਾਂ ਨੂੰ ਅੰਦਰੂਨੀ ਤੌਰ ਤੇ ਅਪਡੇਟ ਕਰਦਾ ਹੈ).
  2. ਐਰੇ ਦੀ ਸ਼ੁਰੂਆਤ ਤੋਂ ਇਸ ਦੇ ਅੰਤ ਤਕ ਇਕ ਲੂਪ ਚਲਾਓ.
  3. ਹਰ ਤੱਤ ਲਈ:
    • ਜਾਂਚ ਕਰੋ ਕਿ ਕੀ ਇਹ ਪਹਿਲੇ ਮੈਕਸ ਤੋਂ ਵੱਡਾ ਹੈ:
      • ਜੇ ਸੱਚ ਹੈ:
        • ਸੈਕਿੰਡਮੈਕਸ = ਫਸਟਮੈਕਸ
        • ਫਸਟਮੈਕਸ = ਮੌਜੂਦਾ-ਤੱਤ ਨੂੰ ਅਪਡੇਟ ਕਰੋ
      • ਹੋਰ:
        • ਜੇ ਇਹ ਸੈਕਿੰਡ ਮੈਕਸ ਤੋਂ ਵੱਡਾ ਹੈ
          • ਸੈਕਿੰਡਮੈਕਸ = ਮੌਜੂਦਾ-ਤੱਤ ਨੂੰ ਅਪਡੇਟ ਕਰੋ
  4. ਨਤੀਜਾ ਪ੍ਰਿੰਟ ਕਰੋ

ਐਰੇ ਲੀਟਕੋਡ ਸਲਿ .ਸ਼ਨ ਵਿੱਚ ਦੋ ਤੱਤਾਂ ਦਾ ਵੱਧ ਤੋਂ ਵੱਧ ਉਤਪਾਦ ਲੱਭਣ ਲਈ ਐਲਗੋਰਿਦਮ ਨੂੰ ਲਾਗੂ ਕਰਨਾ

ਸੀ ++ ਪ੍ਰੋਗਰਾਮ

#include <bits/stdc++.h>
using namespace std;

int maxProduct(vector <int> &a)
{
    int firstMax = 0 , secondMax = 0 , n = a.size();
    for(int i = 0 ; i < n ; i++)
        if(a[i] > firstMax)
        {
            secondMax = firstMax;
            firstMax = a[i];
        }
        else if(a[i] > secondMax)
            secondMax = a[i];

    return (firstMax - 1) * (secondMax - 1);
}

int main()
{
    vector <int> a = {1 , 4 , 5 , 3 , 6 , 4};
    cout << maxProduct(a) << '\n';
}

ਜਾਵਾ ਪ੍ਰੋਗਰਾਮ

class maximum_product
{
    public static void main(String args[])
    {
        int[] a = {1 , 4 , 5 , 3 , 6 , 4};
        System.out.println(maxProduct(a));
    }

    static int maxProduct(int[] a)
    {
        int firstMax = 0 , secondMax = 0 , n = a.length;
        for(int i = 0 ; i < n ; i++)
            if(a[i] > firstMax)
            {
                secondMax = firstMax;
                firstMax = a[i];
            }
            else if(a[i] > secondMax)
                secondMax = a[i];

        return (firstMax - 1) * (secondMax - 1);
    }
}
20

ਐਰੇ ਲੀਟਕੋਡ ਘੋਲ ਵਿੱਚ ਦੋ ਤੱਤਾਂ ਦਾ ਵੱਧ ਤੋਂ ਵੱਧ ਉਤਪਾਦ ਲੱਭਣ ਦੀ ਜਟਿਲਤਾ ਵਿਸ਼ਲੇਸ਼ਣ

ਟਾਈਮ ਜਟਿਲਤਾ

ਓ (ਐਨ), ਐਨ = ਐਰੇ ਦਾ ਆਕਾਰ. ਅਸੀਂ ਸਧਾਰਣ ਤੁਲਨਾ ਕਾਰਜਾਂ ਲਈ ਇਕ ਲੀਨੀਅਰ ਲੂਪ ਚਲਾਉਂਦੇ ਹਾਂ.

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

ਓ (1), ਜਿਵੇਂ ਕਿ ਨਿਰੰਤਰ ਮੈਮੋਰੀ ਵਰਤੀ ਜਾਂਦੀ ਹੈ.