ਸਾਰੇ ਵਿਲੱਖਣ ਤਿੰਨੇ ਜੋ ਇਕ ਦਿੱਤੇ ਮੁੱਲ ਦੇ ਅਨੁਸਾਰ ਹੁੰਦੇ ਹਨ


ਮੁਸ਼ਕਲ ਪੱਧਰ ਦਰਮਿਆਨੇ
ਅਕਸਰ ਪੁੱਛਿਆ ਜਾਂਦਾ ਹੈ ਇਕੱਤਰ ਐਮਾਜ਼ਾਨ ਕੱਟੜਪੰਥੀ
ਅਰੇ ਹੈਸ਼ਿੰਗ ਖੋਜ ਕਰਨਾ

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

ਉਦਾਹਰਨ

ਇੰਪੁੱਟ:

ਐਰ [] = 3,5,7,5,6,1 XNUMX}

ਜੋੜ = 16

ਆਉਟਪੁੱਟ:

(3, 7, 6), (5, 5, 6)

ਸਪਸ਼ਟੀਕਰਨ:

ਟ੍ਰਿਪਲਿਟ ਜੋ ਦਿੱਤੀ ਗਈ ਰਕਮ ਦੇ ਬਰਾਬਰ ਹੈ.

ਇੰਪੁੱਟ:

ਐਰ [] = 3,4,1,5,4 XNUMX}

ਜੋੜ = 20

ਆਉਟਪੁੱਟ:

ਇੱਥੇ ਕੋਈ ਤ੍ਰਿਪਤੀਆਂ ਨਹੀਂ ਹਨ ਜੋ ਦਿੱਤੀ ਗਈ ਸੰਖਿਆ ਦੇ ਨਾਲ ਬਣ ਸਕਦੀਆਂ ਹਨ

ਐਲਗੋਰਿਥਮ

  1. ਦਿੱਤੀ ਗਈ ਐਰੇ ਨੂੰ ਸੌਰਟ ਕਰੋ.
  2. ਬੁਲੀਅਨ ਵੇਰੀਏਬਲ isFound ਨੂੰ ਗਲਤ ਸੈੱਟ ਕਰੋ.
  3. ਜਦਕਿ i = 0 ਤੋਂ i
    1. ਸੈੱਟ j = i + 1, ਕੇ = ਐਨ -1.
    2. ਜਦੋਂ ਕਿ ਜੇ <ਕੇ
      1. ਜਾਂਚ ਕਰੋ ਕਿ ਕੀ ਤਿੰਨ ਤੱਤ ਇਕੱਠੇ ਦਿੱਤੀ ਰਕਮ ਨੂੰ ਜੋੜਦੇ ਹਨ.
        1. ਜੇ ਸਹੀ ਹੈ, ਤਦ ਸਾਰੇ ਤਿੰਨ ਨੰਬਰ ਪ੍ਰਿੰਟ ਕਰੋ ਅਤੇ isFound to true ਸੈੱਟ ਕਰੋ.
      2. ਹੋਰ ਜਾਂਚ ਕਰੋ ਕਿ ਤਿੰਨਾਂ ਤੱਤਾਂ ਦਾ ਜੋੜ ਜੋੜ ਨਾਲੋਂ ਵੱਡਾ ਹੈ ਜਾਂ ਨਹੀਂ.
        1. ਜੇ ਸਹੀ ਹੈ, ਤਾਂ ਕੇ ਦੇ ਮੁੱਲ ਨੂੰ 1 ਨਾਲ ਘਟਾਓ.
      3. ਜਾਂਚ ਕਰੋ ਕਿ ਕੀ ਤਿੰਨ ਤੱਤਾਂ (ਮੌਜੂਦਾ ਐਰੇ ਐਲੀਮੈਂਟਸ) ਦਾ ਜੋੜ ਜੋੜ ਨਾਲੋਂ ਘੱਟ ਹੈ.
        1. ਜੇ ਸਹੀ ਹੈ ਤਾਂ j ਦੇ ਮੁੱਲ ਨੂੰ 1 ਨਾਲ ਵਧਾਓ.
  4. ਜਾਂਚ ਕਰੋ ਕਿ ਕੀ ਆਈਫਾਉਂਡ ਗਲਤ ਰਹਿੰਦਾ ਹੈ, ਇਹ ਸਿੱਟਾ ਕੱ .ਦਾ ਹੈ ਕਿ ਕੋਈ ਤ੍ਰਿਪਟ ਨਹੀਂ ਬਣਾਇਆ ਜਾ ਸਕਦਾ.

ਕਥਾ

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

ਐਰੇ ਨੂੰ ਕ੍ਰਮਬੱਧ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਨੇਸਟਡ ਲੂਪ ਤੋਂ ਸ਼ੁਰੂ ਕਰਦਿਆਂ, ਅਸੀਂ ਐਰੇ ਨੂੰ ਲੰਬਾਈ n-1 ਤੱਕ ਲੰਘਾਂਗੇ. ਵੇਰੀਏਬਲ ਵੈਲਯੂਜ ਵਿਚੋਂ ਇਕ ਨੂੰ i + 1 ਦੇ ਤੌਰ ਤੇ ਸੈਟ ਕਰਨਾ, ਇਕ ਹੋਰ ਵੈਲਯੂ ਨੂੰ n-1 ਤੇ ਰੱਖਣਾ. ਅੰਦਰੂਨੀ ਲੂਪ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਐਰੇ ਦੇ ਸਾਰੇ ਗੁਣਾਂ ਨੂੰ ਪਾਰ ਕਰਾਂਗੇ, ਅਤੇ ਜਾਂਚ ਕਰਾਂਗੇ ਕਿ ਦਿੱਤੀ ਗਈ ਗਿਣਤੀ 'ਜੋੜ' ਤਿੰਨ ਮੌਜੂਦਾ ਐਰੇ ਐਲੀਮੈਂਟਸ (ਏਰ [i] + ਏਰ [ਜੇ] + ਐਰ [ਕੇ) ਦੇ ਬਰਾਬਰ ਹੈ ਜਾਂ ਨਹੀਂ ]) ਬਰਾਬਰ ਹੈ ਜਾਂ ਨਹੀਂ. ਜੇ ਕੰਡੀਸ਼ਨ ਸੰਤੁਸ਼ਟ ਹੋ ਜਾਂਦੀ ਹੈ, ਅਸੀਂ ਇੱਕ ਐਰੇ ਦੇ ਸਾਰੇ ਮੌਜੂਦਾ ਮੁੱਲ ਪ੍ਰਿੰਟ ਕਰਨ ਜਾ ਰਹੇ ਹਾਂ ਅਤੇ isFound value ਨੂੰ true ਸੈੱਟ ਕਰਦੇ ਹਾਂ, ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਸਾਨੂੰ ਗਲਤ ਵੈਲਯੂ ਵਾਪਸ ਨਹੀਂ ਕਰਨੀ ਚਾਹੀਦੀ.

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

ਇਹ ਉਦੋਂ ਤਕ ਜਾਰੀ ਰਹੇਗਾ ਜਦੋਂ ਤੱਕ ਐਰੇ ਦੇ ਸਾਰੇ ਮੁੱਲ ਟ੍ਰਾਂਸ ਨਹੀਂ ਹੋ ਜਾਂਦੇ. ਅਤੇ ਅਸੀ isFound ਵੈਲਿ return ਨੂੰ ਵਾਪਸ ਕਰਨ ਜਾ ਰਹੇ ਹਾਂ, ਜੋ ਕਿ ਸਹੀ ਦੇ ਰੂਪ ਵਿੱਚ ਵਾਪਿਸ ਆ ਸਕਦੀ ਹੈ ਜੇ ਸਾਨੂੰ ਕੋਈ ਵੀ ਟ੍ਰਿਪਲੈਟਸ ਅਤੇ ਗਲਤ ਮਿਲਿਆ ਜੇ ਸਾਨੂੰ ਕੋਈ ਨਹੀਂ ਮਿਲਿਆ.

ਲਾਗੂ

ਸੀ ++ ਪ੍ਰੋਗਰਾਮ ਸਾਰੇ ਵਿਲੱਖਣ ਟ੍ਰਿਪਲਟਸ ਲਈ ਜੋ ਇੱਕ ਦਿੱਤੇ ਮੁੱਲ ਦੇ ਅਨੁਸਾਰ ਹੁੰਦੇ ਹਨ

#include<iostream>
#include<algorithm>

using namespace std;

int getTripletOfSum(int arr[], int n, int sum)
{
    int i, j, k;
    bool isFound=false;
    sort(arr, arr + n);
    for(i = 0; i < n - 2; i++)
    {
        j = i + 1;
        k = n - 1;

        while(j < k)
        {
            if(arr[i] + arr[j] + arr[k] == sum)
            {
                cout<<"["<<arr[i]<<" "<<arr[j]<<" "<<arr[k]<<"]"<<endl;
                j++;
                k--;
                isFound=true;
            }
            else if(arr[i] + arr[j] + arr[k] > sum)
                k--;
            else
                j++;
        }
    }
    return isFound;
}
int main()
{
    int nums[] = {3,5,7,5,6,1};
    int n = sizeof(nums) / sizeof(nums[0]);
    int sum = 16;
    if(!getTripletOfSum(nums, n, sum))
        cout << "There are no triplets that can be formed with the given number";

    return 0;
}
[3 6 7]
[5 5 6]

ਜਾਵਾ ਪ੍ਰੋਗਰਾਮ ਸਾਰੇ ਵਿਲੱਖਣ ਟ੍ਰਿਪਲਟਸ ਲਈ ਜੋ ਇੱਕ ਦਿੱਤੇ ਮੁੱਲ ਦੇ ਅਨੁਸਾਰ ਹੁੰਦੇ ਹਨ

import java.util.Arrays;

public class TripletsWithSum
{
    public static boolean getTripletOfSum(int arr[], int sum)
    {
        Arrays.sort(arr);

        boolean isFound=false;

        for (int i = 0; i < arr.length - 2; i++)
        {
            int j = i + 1;
            int k = arr.length - 1;
            while (j < k)
            {
                if (arr[i] + arr[j] + arr[k] == sum)
                {
                    System.out.println("["+arr[i] + " " + arr[j] +" " +arr[k]+"]");
                    j++;
                    k--;
                    isFound=true;
                }
                else if (arr[i] + arr[j] + arr[k] < sum)
                    j++;

                else
                    k--;
            }
        }
        return isFound;
    }
    public static void main(String[] args)
    {
        int arr[] = {3,5,7,5,6,1};
        int sum = 16;
        if (!getTripletOfSum(arr, sum))
        {
            System.out.println("There are no triplets that can be formed with the given number");
        }
    }
}
[3 6 7]
[5 5 6]

ਸਾਰੇ ਵਿਲੱਖਣ ਤਿੰਨਾਂ ਲਈ ਜਟਿਲਤਾ ਵਿਸ਼ਲੇਸ਼ਣ ਜੋ ਇੱਕ ਦਿੱਤੇ ਮੁੱਲ ਦੇ ਅਨੁਸਾਰ ਹੁੰਦੇ ਹਨ

ਟਾਈਮ ਜਟਿਲਤਾ

ਓ (ਐਨ2ਜਿੱਥੇ ਕਿ “ਐਨ” ਐਰੇ ਵਿਚਲੇ ਤੱਤਾਂ ਦੀ ਗਿਣਤੀ ਹੈ.

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

ਹੇ (n) ਜਿੱਥੇ ਕਿ “ਐਨ” ਐਰੇ ਵਿਚਲੇ ਤੱਤਾਂ ਦੀ ਗਿਣਤੀ ਹੈ.