ਦੋ ਜੋੜੀਆਂ ਸੂਚੀਆਂ ਵਿੱਚੋਂ ਜੋੜਿਆਂ ਦੀ ਗਿਣਤੀ ਕਰੋ ਜਿਨ੍ਹਾਂ ਦਾ ਜੋੜ ਇੱਕ ਦਿੱਤੇ ਮੁੱਲ ਦੇ ਬਰਾਬਰ ਹੈ


ਮੁਸ਼ਕਲ ਪੱਧਰ ਦਰਮਿਆਨੇ
ਅਕਸਰ ਪੁੱਛਿਆ ਜਾਂਦਾ ਹੈ ਅਡੋਬ ਐਮਾਜ਼ਾਨ ਅਵਲਾਰਾ ਇਕਸਪੀਡੀਆ ਕੱਟੜਪੰਥੀ ਗੂਗਲ ਅਸਲ ਵਿੱਚ Microsoft ਦੇ ਪੇਪਾਲ Tesla
ਹੈਸ਼ਿੰਗ ਲਿੰਕਡ-ਲਿਸਟ ਲੜੀਬੱਧ

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

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

ਉਦਾਹਰਨ

LinkedList1 = 11 à 6 à 1 à 8

LinkedList2 = 5 à 3 à 1 à 9

Sum = 9
2

ਵਿਆਖਿਆ: ਇੱਥੇ ਦੋ ਜੋੜੇ ਹਨ, ਜਿਵੇਂ ਕਿ, 6, 3, ਅਤੇ 8, 1 ਜੋ ਕਿ ਦਿੱਤੇ ਮੁੱਲ 9 ਦੇ ਮੁੱਲ ਨੂੰ ਜੋੜਦਾ ਹੈ.

 

ਲਿੰਕਡ ਸੂਚੀਆਂ ਵਿੱਚੋਂ ਜੋੜਿਆਂ ਦੀ ਗਿਣਤੀ ਕਰਨ ਲਈ ਐਲਗੋਰਿਦਮ ਜਿਸਦਾ ਜੋੜ ਇੱਕ ਦਿੱਤੇ ਮੁੱਲ ਦੇ ਬਰਾਬਰ ਹੈ

1. Push all the integer values to the two different linked lists.
2. Declare a set.
3. Set the count to 0.
4. Iterate over the first linked list and put all the values of it into the linked list1.
5. Iterate over the second linked list
    1. Check if the set contains the difference between the value of x and a current element of linked list2.
        1. If true then increase the value of count by 1.
6. Return count.

ਕਥਾ

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

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

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

ਦੋ ਜੋੜੀਆਂ ਸੂਚੀਆਂ ਵਿੱਚੋਂ ਜੋੜਿਆਂ ਦੀ ਗਿਣਤੀ ਕਰੋ ਜਿਨ੍ਹਾਂ ਦਾ ਜੋੜ ਇੱਕ ਦਿੱਤੇ ਮੁੱਲ ਦੇ ਬਰਾਬਰ ਹੈ

ਕੋਡ

ਸੀ ++ ਦੋ ਜੋੜੀਆਂ ਸੂਚੀਆਂ ਵਿਚੋਂ ਜੋੜਿਆਂ ਦੀ ਗਿਣਤੀ ਕਰਨ ਲਈ, ਜਿਨ੍ਹਾਂ ਦੀ ਰਕਮ ਇੱਕ ਦਿੱਤੇ ਮੁੱਲ ਦੇ ਬਰਾਬਰ ਹੈ

#include<iostream>
#include<unordered_set>

using namespace std;

struct Node
{
    int data;
    struct Node* next;
};

void implementLinkedList(struct Node** headReference, int newItem)
{
    struct Node* newNode =	(struct Node*) malloc(sizeof(struct Node));

    newNode->data = newItem;

    newNode->next = (*headReference);

    (*headReference) = newNode;
}
int getPairOfsum (struct Node* head1, struct Node* head2,int sum)
{
    int count = 0;

    unordered_set<int> SET;

    while (head1 != NULL)
    {
        SET.insert(head1->data);

        head1 = head1->next;
    }

    while (head2 != NULL)
    {
        if (SET.find(sum - head2->data) != SET.end())
            count++;

        head2 = head2->next;
    }
    return count;
}
int main()
{
    struct Node* head1 = NULL;
    struct Node* head2 = NULL;

    implementLinkedList (&head1,11);
    implementLinkedList (&head1, 6);
    implementLinkedList (&head1, 1);
    implementLinkedList (&head1, 8);

    implementLinkedList (&head2, 5);
    implementLinkedList (&head2, 3);
    implementLinkedList (&head2, 1);
    implementLinkedList (&head2, 9);

    int sum = 9;

    cout << "Count = "<< getPairOfsum (head1, head2, sum);
    return 0;
}
Count = 2

ਦੋ ਜੋੜੀਆਂ ਸੂਚੀਆਂ ਵਿੱਚੋਂ ਜੋੜਿਆਂ ਦੀ ਗਿਣਤੀ ਕਰਨ ਲਈ ਜਾਵਾ ਕੋਡ, ਜਿਸਦਾ ਜੋੜ ਇੱਕ ਦਿੱਤੇ ਮੁੱਲ ਦੇ ਬਰਾਬਰ ਹੈ

import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;

class PairOfSumInLinkedList1
{
    public static int getPairOfsum(LinkedList<Integer> head1, LinkedList<Integer> head2, int sum)
    {
        int count = 0;

        HashSet<Integer> SET = new HashSet<Integer>();

        Iterator<Integer> itr1 = head1.iterator();
        while (itr1.hasNext())
        {
            SET.add(itr1.next());

        }

        Iterator<Integer> itr2 = head2.iterator();
        while (itr2.hasNext())
        {
            if (!(SET.add(sum - itr2.next())))
                count++;

        }
        return count;
    }
    public static void main(String[] args)
    {
        Integer arr1[] = {11, 6, 1, 8};
        Integer arr2[] = {5, 3, 1, 9};

        LinkedList<Integer> head1 = new LinkedList<>(Arrays.asList(arr1));

        LinkedList<Integer> head2 = new LinkedList<>(Arrays.asList(arr2));

        int x = 9;

        System.out.println("Count = " + getPairOfsum(head1, head2, x));
    }
}
Count = 2

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

ਟਾਈਮ ਜਟਿਲਤਾ

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

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

ਕਿਉਂਕਿ ਅਸੀਂ ਇਨਪੁਟ ਨੂੰ ਦੋ ਲਿੰਕਡ ਸੂਚੀਆਂ ਵਿੱਚ ਸਟੋਰ ਕੀਤਾ ਹੈ ਅਤੇ ਹੈਸ਼ਸੈੱਟ ਦੀ ਵਰਤੋਂ ਕੀਤੀ. ਸਾਡੇ ਕੋਲ ਇੱਕ ਲੀਨੀਅਰ ਸਪੇਸ ਗੁੰਝਲਦਾਰਤਾ ਹੱਲ ਹੈ.