ਜੋੜੀ ਦੇ ਤੱਤ ਵੱਖ-ਵੱਖ ਕਤਾਰਾਂ ਵਿੱਚ ਹਨ, ਜੋ ਕਿ ਦਿੱਤੀ ਰਕਮ ਦੇ ਨਾਲ ਜੋੜੀ ਲੱਭੋ


ਮੁਸ਼ਕਲ ਪੱਧਰ ਦਰਮਿਆਨੇ
ਅਕਸਰ ਪੁੱਛਿਆ ਜਾਂਦਾ ਹੈ ਐਮਾਜ਼ਾਨ ਡੀਈ ਸ਼ਾ ਦਿਸ਼ਾ ਗ੍ਰੇਓਰੇਂਜ ਅਸਲ ਵਿੱਚ ਕਿਰਾਏ ਨਿਰਦੇਸ਼ਿਕਾ Teradata
ਅਰੇ ਹੈਸ਼ ਮੈਟਰਿਕਸ

ਸਮੱਸਿਆ ਦਾ ਬਿਆਨ

“ਜੋੜੀ ਦੇ ਤੱਤ ਵੱਖੋ ਵੱਖਰੀਆਂ ਕਤਾਰਾਂ ਵਿਚ ਹੁੰਦੇ ਹਨ,” ਜਿਵੇਂ ਕਿ ਜੋੜਿਆਂ ਦੇ ਜੋੜ ਲੱਭੋ ਸਮੱਸਿਆ ਦੱਸਦੀ ਹੈ ਕਿ ਤੁਹਾਨੂੰ ਪੂਰਨ ਅੰਕ ਦਾ ਇਕ ਮੈਟ੍ਰਿਕਸ ਅਤੇ “ਜੋੜ” ਕਿਹਾ ਜਾਂਦਾ ਹੈ. ਸਮੱਸਿਆ ਬਿਆਨ ਇਕ ਮੈਟ੍ਰਿਕਸ ਵਿਚਲੇ ਉਨ੍ਹਾਂ ਸਾਰੇ ਜੋੜਿਆਂ ਦਾ ਪਤਾ ਲਗਾਉਣ ਲਈ ਕਹਿੰਦਾ ਹੈ ਜੋ ਇਕ ਦਿੱਤੇ ਮੁੱਲ ਦੇ ਅਨੁਸਾਰ ਬਣਦੇ ਹਨ, ਅਤੇ ਜੋੜ ਦੇ ਦੋਵੇਂ ਅੰਕ ਇਕ ਵੱਖਰੀ ਕਤਾਰ ਵਿਚ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ. (ਦੋਵੇਂ ਨੰਬਰ ਇਕੋ ਕਤਾਰ ਤੋਂ ਨਹੀਂ ਹੋਣੇ ਚਾਹੀਦੇ).

ਉਦਾਹਰਨ

int matrix[][]= {{3, 4, 7, 2},

{8, 9, 1, 10},

{5, 4, 0, 4},

{12, 0, 1, 13}};



sum = 15
(3, 12), (7, 8), (2, 13), (10, 5)

ਵਿਆਖਿਆ: ਹਰੇਕ ਜੋੜੀ ਦੀ ਹਰੇਕ ਗਿਣਤੀ ਵੱਖਰੀ ਕਤਾਰ ਤੋਂ ਹੈ.

ਜੋੜੀ ਦੇ ਤੱਤ ਵੱਖ-ਵੱਖ ਕਤਾਰਾਂ ਵਿੱਚ ਹੁੰਦੇ ਹਨ, ਜੋ ਕਿ ਦਿੱਤੀ ਰਕਮ ਨਾਲ ਜੋੜਿਆਂ ਨੂੰ ਲੱਭਣ ਲਈ ਐਲਗੋਰਿਦਮ

1. Declare a map.
2. Put all the values of the matrix into the map with their row and column index.
3. Traverse the matrix.
  1. Set the remainingValue to the difference of sum and each value of the matrix.
  2. Check if the map contains the value of remainingValue if true then get its row and column index which we already put it into the map.
    1. Check if this row value is not equal to current i and also a row is greater than i.
      1. If true then print the matrix[i][j] and matrix[row][column].
4. Keep repeating the process until the whole matrix is traversed.

ਕਥਾ

ਸਾਨੂੰ ਪੂਰਨ ਅੰਕ ਦਾ ਇੱਕ ਮੈਟ੍ਰਿਕਸ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ. ਸਾਨੂੰ ਸਾਰਿਆਂ ਦੇ ਜੋੜਿਆਂ ਨੂੰ ਇਕ ਮੈਟ੍ਰਿਕਸ ਵਿਚ ਲੱਭਣਾ ਹੈ ਜਿਵੇਂ ਕਿ ਹਰੇਕ ਜੋੜੀ ਦੇ ਤੱਤ ਦੀ ਕੀਮਤ ਇਕ ਬਰਾਬਰ ਦੀ ਕੀਮਤ ਦੇ ਬਰਾਬਰ ਹੁੰਦੀ ਹੈ. ਅਤੇ ਇਥੇ ਇਕ ਸ਼ਰਤ ਵੀ ਦਿੱਤੀ ਗਈ ਹੈ, ਜੋੜੀ ਵਿਚ ਜੋ ਨੰਬਰ ਅਸੀਂ ਚੁਣਦੇ ਹਾਂ ਉਹ ਇਕ ਮੈਟ੍ਰਿਕਸ ਵਿਚ ਵੱਖਰੀਆਂ ਕਤਾਰਾਂ ਵਿਚੋਂ ਹੋਣੀਆਂ ਚਾਹੀਦੀਆਂ ਹਨ. ਜੇ ਅਸੀਂ ਇਸ ਨੂੰ ਭੋਲੇ ਪਹੁੰਚ ਨਾਲ ਹੱਲ ਕਰਨਾ ਜਾਰੀ ਰੱਖਦੇ ਹਾਂ. ਅਤੇ ਤੱਤ ਵਿਚ ਹਰੇਕ ਕਤਾਰ ਨੂੰ ਪਾਰ ਕਰੋ ਫਿਰ ਇਹ O (n) ਲਵੇਗਾ4). ਅਸੀਂ ਹੈਸ਼ਿੰਗ ਜਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇਸਨੂੰ ਹੱਲ ਕਰਾਂਗੇ ਨਕਸ਼ਾ / ਹੈਸ਼ਮੈਪ. ਅਸੀਂ ਇਕ ਨਕਸ਼ਾ ਘੋਸ਼ਿਤ ਕਰਾਂਗੇ. ਮੈਟ੍ਰਿਕਸ ਨੂੰ ਭਜਾਉਣਾ ਸ਼ੁਰੂ ਕਰੋ, ਅਤੇ ਮੈਟ੍ਰਿਕਸ ਦੇ ਤੱਤ ਨੁੰ ਇੱਕ ਕੁੰਜੀ ਦੇ ਰੂਪ ਵਿੱਚ ਪਾਓ. ਅਤੇ ਇਸਦੇ ਮੈਟ੍ਰਿਕਸ ਤੱਤ ਦੀ ਕਤਾਰ ਅਤੇ ਕਾਲਮ ਇੰਡੈਕਸ ਇੱਕ ਮੁੱਲ ਦੇ ਰੂਪ ਵਿੱਚ.

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

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

ਜੋੜੀ ਦੇ ਤੱਤ ਵੱਖ-ਵੱਖ ਕਤਾਰਾਂ ਵਿੱਚ ਹਨ, ਜੋ ਕਿ ਦਿੱਤੀ ਰਕਮ ਦੇ ਨਾਲ ਜੋੜੀ ਲੱਭੋ

ਕੋਡ

ਸੀ ++ ਕੋਡ, ਜੋੜੀ ਦੇ ਤੱਤ ਵੱਖ-ਵੱਖ ਕਤਾਰਾਂ ਵਿੱਚ ਹੁੰਦੇ ਹਨ, ਜੋ ਕਿ ਦਿੱਤੀ ਰਕਮ ਦੇ ਨਾਲ ਜੋੜਿਆਂ ਨੂੰ ਲੱਭਣ ਲਈ

#include<iostream>
#include<unordered_map>

using namespace std;

const int MAX = 100;

void makePairWithGivenSum (int matrix[][MAX], int n, int sum)
{
    unordered_map<int, pair<int, int> > MAP;
    for (int i=0; i<n; i++)
        for (int j=0; j<n; j++)
            MAP[matrix[i][j]] = make_pair(i, j);

    for (int i=0; i<n; i++)
    {
        for (int j=0; j<n; j++)
        {
            int remainingSum = sum - matrix[i][j];
            auto it = MAP.find(remainingSum);

            if (it != MAP.end())
            {
                pair<int, int> p = it->second;
                int row = p.first, col = p.second;
                if (row != i && row > i)
                    cout << "(" << matrix[i][j] << ", "
                         << matrix[row][col] << "), ";
            }
        }
    }
}
int main()
{
    int n = 4, sum = 11;
    int matrix[][MAX]= {{3, 4, 7, 2},
        {8, 9, 1, 10},
        {5, 4, 0, 4},
        {12, 0, 1, 13}
    };
    makePairWithGivenSum (matrix, n, sum);
    return 0;
}
(3, 8), (7, 4), (2, 9), (10, 1),

ਜਾਵਾ ਕੋਡ ਨੂੰ ਜੋੜਾਂ ਦਾ ਪਤਾ ਲਗਾਉਣ ਲਈ ਜਿਵੇਂ ਕਿ ਜੋੜੀ ਦੇ ਤੱਤ ਵੱਖਰੀਆਂ ਕਤਾਰਾਂ ਵਿੱਚ ਹੁੰਦੇ ਹਨ

import java.util.HashMap;
class Pair
{
    int first, second;
    Pair(int first, int second)
    {
        this.first=first;
        this.second=second;
    }
}
class pairSum
{
    public static void makePairWithGivenSum(int matrix[][], int n, int sum)
    {
        HashMap<Integer, Pair > MAP=new HashMap<Integer, Pair>();
        for (int i=0; i<n; i++)
        {
            for (int j=0; j<n; j++)
            {
                MAP.put(matrix[i][j], new Pair(i,j));
            }
        }
        for (int i=0; i<n; i++)
        {
            for (int j=0; j<n; j++)
            {
                int remainingSum = sum - matrix[i][j];

                if (MAP.containsKey(remainingSum))
                {
                    Pair p = MAP.get(remainingSum);
                    int row = p.first, col = p.second;
                    if (row != i && row > i)
                        System.out.print("(" + matrix[i][j] + ", " + matrix[row][col] + "), ");

                }
            }
        }
    }
    public static void main(String [] args)
    {
        int n = 4, sum = 15;
        int matrix[][]= {{3, 4, 7, 2},
            {8, 9, 1, 10},
            {5, 4, 0, 4},
            {12, 0, 1, 13}
        };
        makePairWithGivenSum (matrix, n, sum);
    }
}
(3, 12), (7, 8), (2, 13), (10, 5),

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

ਟਾਈਮ ਜਟਿਲਤਾ

ਅਸੀਂ ਮੈਟ੍ਰਿਕਸ ਨੂੰ ਟ੍ਰਾਂਸ ਕਰ ਰਹੇ ਹਾਂ ਅਤੇ ਕਿਉਂਕਿ ਅਸੀਂ ਹੈਸ਼ਮੈਪ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹਾਂ, ਅਸੀਂ ਪ੍ਰਾਪਤ ਕਰਨ ਦੇ ਯੋਗ ਹਾਂ ਓ (ਐਨ2ਜਿੱਥੇ ਕਿ “ਐਨ” ਮੈਟ੍ਰਿਕਸ ਵਿੱਚ ਤੱਤ ਦੀ ਗਿਣਤੀ ਹੈ.

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

ਓ (ਐਨ) ਜਿੱਥੇ ਕਿ “ਐਨ” ਮੈਟ੍ਰਿਕਸ ਵਿੱਚ ਤੱਤ ਦੀ ਗਿਣਤੀ ਹੈ.