ਦਿੱਤੀ ਗਈ ਸੰਖਿਆ ਦੇ ਬਰਾਬਰ ਉਤਪਾਦ ਦੇ ਨਾਲ ਤਿੰਨ ਗੁਣਾਂ ਦੀ ਗਿਣਤੀ ਕਰੋ


ਮੁਸ਼ਕਲ ਪੱਧਰ ਦਰਮਿਆਨੇ
ਅਕਸਰ ਪੁੱਛਿਆ ਜਾਂਦਾ ਹੈ ਇਕੱਤਰ ਐਮਾਜ਼ਾਨ ਨੂੰ Cisco ਫਲਿੱਪਕਾਰਟ ਕੁਲਿਜ਼ਾ ਪਬਲਿਕਸ ਸੇਪੀਐਂਟ
ਅਰੇ ਹੈਸ਼ ਦੋ ਪੁਆਇੰਟਰ

ਸਮੱਸਿਆ "ਦਿੱਤੀ ਗਈ ਸੰਖਿਆ ਦੇ ਬਰਾਬਰ ਉਤਪਾਦ ਦੇ ਨਾਲ ਤਿੰਨ ਗੁਣਾਂ ਦੀ ਗਿਣਤੀ ਕਰੋ" ਦੱਸਦੀ ਹੈ ਕਿ ਸਾਨੂੰ ਪੂਰਨ ਅੰਕ ਅਤੇ ਇੱਕ ਨੰਬਰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ m. ਸਮੱਸਿਆ ਬਿਆਨ ਮੀਟਰ ਦੇ ਬਰਾਬਰ ਦੇ ਤਿੰਨ ਗੁਣਾਂ ਦੀ ਗਿਣਤੀ ਦਾ ਪਤਾ ਲਗਾਉਣ ਲਈ ਕਹਿੰਦਾ ਹੈ.

ਉਦਾਹਰਨ

arr[] = {1,5,2,6,10,3}
m=30
3

ਕਥਾ

ਮੀਟਰ ਦੇ ਬਰਾਬਰ ਦੇ ਉਤਪਾਦਾਂ ਨੂੰ ਬਣਾਉਣ ਵਾਲੇ ਟ੍ਰਿਪਲਟਸ (1,5,6), (5,2,3) ਅਤੇ (1,3,10) ਹਨ

ਦਿੱਤੀ ਗਈ ਸੰਖਿਆ ਦੇ ਬਰਾਬਰ ਉਤਪਾਦ ਦੇ ਨਾਲ ਤਿੰਨ ਗੁਣਾਂ ਦੀ ਗਿਣਤੀ ਕਰੋ

arr[] = {2,4,5,1,10}
m=20
2

ਕਥਾ

ਮੀਟਰ ਦੇ ਬਰਾਬਰ ਦੇ ਉਤਪਾਦਾਂ ਨੂੰ ਬਣਾਉਣ ਵਾਲੇ ਤਿਕੋਣ ਹਨ (2,1,10), (4,5,1)

ਐਲਗੋਰਿਥਮ

  1. ਘੋਸ਼ਣਾ ਏ ਫੋਲਡਰ ਨੂੰ.
  2. ਟਰੈਕਿੰਗ ਕਰਕੇ ਹਰੇਕ ਤੱਤ ਦੇ ਤਤਕਰਾ ਨਕਸ਼ੇ ਵਿੱਚ ਸਟੋਰ ਕਰੋ ਐਰੇ.
  3. 0 ਨੂੰ ਆਉਟਪੁੱਟ ਦਿਓ.
  4. ਨੇਸਟਡ ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਐਰੇ ਨੂੰ ਦੁਬਾਰਾ ਪਾਰ ਕਰਨਾ:
    1. ਜਾਂਚ ਕਰੋ ਕਿ ((ਅਰਰ [ਮੈਂ] * ਅਰਰ [ਜੇ] <= ਐਮ)) ਅਤੇ& (ਐਰ [i] * ਅਰਰ [ਜੇ]! = 0) ਅਤੇ (ਐਮ% (ਐਰ [ਆਈ] * ਅਰਰ [ਜੇ])) == 0 )).
      1. ਜੇ ਇਹ ਸਹੀ ਪਾਇਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ m / (arr [i] * arr [j]) ਲੱਭੋ ਅਤੇ ਨਕਸ਼ੇ ਵਿੱਚ ਇਸਦੀ ਖੋਜ ਕਰੋ.
    2. ਇਹ ਵੀ ਜਾਂਚ ਲਓ ਕਿ ਜੋ ਤੀਸਰਾ ਤੱਤ ਅਸੀਂ ਪਾਇਆ ਹੈ ਉਹ ਮੌਜੂਦਾ ਦੋ ਤੱਤ (ਅਰਰ [i] ਅਤੇ ਅਰਰ [ਜੇ]) ਦੇ ਬਰਾਬਰ ਨਹੀਂ ਹੈ.
      1. ਜੇ ਸਥਿਤੀ ਸੰਤੁਸ਼ਟ ਹੋ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਆਉਟਪੁੱਟ ਦੀ ਗਿਣਤੀ ਨੂੰ 1 ਨਾਲ ਵਧਾਓ.
  5. ਵਾਪਸੀ ਆਉਟਪੁੱਟ.

ਕਥਾ

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

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

ਐਰੇ ਦੇ ਟ੍ਰਾਂਸਵਲ ਤੋਂ ਬਾਅਦ, ਸਾਡੇ ਕੋਲ ਹੈਸ਼ਮੈਪ ਵਿਚ ਮੁੱਲ ਹਨ. ਆਉਟਪੁੱਟ ਦੀ ਵੈਲਯੂ ਨੂੰ 0 ਤੇ ਸੈੱਟ ਕਰੋ. ਹੁਣ, ਅਸੀਂ ਨੇਸਟਡ ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰਨ ਜਾ ਰਹੇ ਹਾਂ. ਜਿਸ ਵਿਚ ਅਸੀਂ ਬਾਹਰੀ ਲੂਪ ਵਿਚ ਇਕ ਤੱਤ ਲੈਂਦੇ ਹਾਂ ਅਤੇ ਅੰਦਰੂਨੀ ਲੂਪ ਵਿਚ ਅਗਲਾ ਇਕ ਹੋਰ ਤੱਤ ਚੁਣੋ. ਫਿਰ ਅਸੀਂ ਤੀਜੇ ਤੱਤ ਦਾ ਪਤਾ ਲਗਾਉਣ ਜਾ ਰਹੇ ਹਾਂ. ਸਾਰੀ ਸਥਿਤੀ ਜੋ 'if ਸਟੇਟਮੈਂਟ' ਵਿਚ ਹੈ, ਦੀ ਵਰਤੋਂ ਤੀਜੇ ਤੱਤ ਨੂੰ ਲੱਭਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ. ਅਰਰ ਕਰਨ ਤੋਂ ਬਾਅਦ [i] * ਅਰਰ [ਜੇ] ਸਾਨੂੰ ਲੱਭਣਾ ਹੈ ਤੀਜਾ ਤੱਤ. ਇਸ ਲਈ ਇਕ ਸਧਾਰਨ ਨੋਟ 'ਤੇ, ਜੇ ਇਕ * ਬੀ * ਸੀ = ਐਮ ⇒ ਤਾਂ ਸੀ = ਐਮ / ਏ * ਬੀ.

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

C ++ ਕੋਡ ਨੂੰ ਦਿੱਤੀ ਗਈ ਸੰਖਿਆ ਦੇ ਬਰਾਬਰ ਉਤਪਾਦ ਦੇ ਨਾਲ ਤਿੰਨ ਗੁਣਾਂ ਦੀ ਗਿਣਤੀ ਕਰਨ ਲਈ

#include<iostream>
#include<unordered_map>
using namespace std;

int getProductTriplets(int arr[], int n, int m)
{
    unordered_map<int, int> numindex;
    for (int i = 0; i < n; i++)
        numindex[arr[i]] = i;

    int output = 0;

    for (int i = 0; i < n - 1; i++)
    {
        for (int j = i + 1; j < n; j++)
        {
            if ((arr[i] * arr[j] <= m) && (arr[i] * arr[j] != 0) && (m % (arr[i] * arr[j]) == 0))
            {
                int third = m / (arr[i] * arr[j]);
                auto it = numindex.find(third);

                if (third != arr[i] && third != arr[j]&& it != numindex.end() && it->second > i&& it->second > j)
                    output++;
            }
        }
    }
    return output;
}
int main()
{
    int arr[] = {1,5,2,6,10,3};
    int n = sizeof(arr) / sizeof(arr[0]);
    int m = 30;

    cout <<"Total product triplets are: "<<getProductTriplets(arr, n, m);
    return 0;
}
Total product triplets are: 3

ਜਾਵਾ ਕੋਡ, ਦਿੱਤੀ ਗਈ ਸੰਖਿਆ ਦੇ ਬਰਾਬਰ ਦੇ ਉਤਪਾਦ ਦੇ ਨਾਲ ਤਿੰਨਾਂ ਦੀ ਗਿਣਤੀ ਕਰਨ ਲਈ

import java.util.HashMap;

class TripletProductPair
{
    public static int getProductTriplets(int arr[], int n, int m)
    {
        HashMap<Integer, Integer> numindex = new HashMap<Integer, Integer>(n);
        for (int i = 0; i < n; i++)
            numindex.put(arr[i], i);

        int output = 0;
        for (int i = 0; i < n - 1; i++)
        {
            for (int j = i + 1; j < n; j++)
            {

                if ((arr[i] * arr[j] <= m) && (arr[i] * arr[j] != 0) && (m % (arr[i] * arr[j]) == 0))
                {
                    int third = m / (arr[i] * arr[j]);

                    numindex.containsKey(third);
                    if (third != arr[i] && third != arr[j]&& numindex.containsKey(third) && numindex.get(third) > i && numindex.get(third) > j)
                    {
                        output++;
                    }
                }
            }
        }
        return output;
    }
    public static void main(String[] args)
    {
        int arr[] = {1,5,2,6,10,3};
        int m = 30;
        System.out.println("Total product triplets are: "+getProductTriplets(arr, arr.length, m));
    }
}
Total product triplets are: 3

ਜਟਿਲਤਾ ਵਿਸ਼ਲੇਸ਼ਣ

ਟਾਈਮ ਜਟਿਲਤਾ

ਓ (ਐਨ2ਜਿੱਥੇ ਕਿ “ਐਨ” ਐਰੇ ਵਿਚਲੇ ਤੱਤਾਂ ਦੀ ਗਿਣਤੀ ਹੈ. ਕਿਉਂਕਿ ਅਸੀਂ ਦੋ ਨੇਸਟਡ ਲੂਪਾਂ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਹੈ ਅਤੇ ਤੀਜੇ ਐਲੀਮੈਂਟ ਦੀ ਭਾਲ ਲਈ ਹੈਸ਼ਮੈਪ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਹੈ. ਇਸ ਲਈ, ਇਹ ਸਰਚ ਓਪਰੇਸ਼ਨ ਹੇਸ਼ਮੈਪ ਦੁਆਰਾ ਓ (1) ਵਿੱਚ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ ਜੋ ਪਹਿਲਾਂ ਇੱਕ ਭੋਲੇਪਣ ਵਿੱਚ ਓ (ਐਨ) ਸਮੇਂ ਕੀਤਾ ਜਾ ਰਿਹਾ ਸੀ. ਇਸ ਤਰ੍ਹਾਂ ਇਹ ਰਫਤਾਰ ਹੈਸ਼ਮੈਪ ਦੇ ਕਾਰਨ ਹੈ.

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

ਹੇ (n) ਜਿੱਥੇ ਕਿ “ਐਨ” ਐਰੇ ਵਿਚਲੇ ਤੱਤਾਂ ਦੀ ਗਿਣਤੀ ਹੈ. ਕਿਉਂਕਿ ਅਸੀਂ ਸਾਰੇ ਤੱਤ ਨਕਸ਼ੇ ਵਿੱਚ ਸਟੋਰ ਕਰਾਂਗੇ. ਸਪੇਸ ਦੀ ਜਟਿਲਤਾ ਲੀਨੀਅਰ ਹੈ.