கொடுக்கப்பட்ட மதிப்பைக் குறிக்கும் அனைத்து தனித்துவமான மும்மூர்த்திகள்


சிரமம் நிலை நடுத்தர
அடிக்கடி கேட்கப்படுகிறது அகோலைட் அமேசான் வெறியர்கள்
அணி ஹேஷிங் தேடி

நாங்கள் ஒரு கொடுத்துள்ளோம் வரிசை முழு எண் மற்றும் கொடுக்கப்பட்ட எண் 'தொகை'. கொடுக்கப்பட்ட எண் 'தொகை' வரை சேர்க்கும் மும்மடங்கைக் கண்டுபிடிக்க சிக்கல் அறிக்கை கேட்கிறது.

உதாரணமாக

உள்ளீடு:

arr [] = {3,5,7,5,6,1}

தொகை = 16

வெளியீடு:

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

விளக்கம்:

கொடுக்கப்பட்ட தொகைக்கு சமமான மும்மடங்கு.

உள்ளீடு:

arr [] = {3,4,1,5,4}

தொகை = 20

வெளியீடு:

கொடுக்கப்பட்ட எண்ணைக் கொண்டு உருவாக்கக்கூடிய மும்மூர்த்திகளும் இல்லை

அல்காரிதம்

  1. கொடுக்கப்பட்ட வரிசையை வரிசைப்படுத்தவும்.
  2. பூலியன் மாறி isFound ஐ தவறானது என அமைக்கவும்.
  3. நான் = 0 முதல் i வரை
    1. J = i + 1, k = n-1 ஐ அமைக்கவும்.
    2. ஜே <கே
      1. கொடுக்கப்பட்ட தொகையை மூன்று கூறுகள் ஒன்றாகச் சேர்க்கிறதா என்று சோதிக்கவும்.
        1. உண்மை என்றால், மூன்று எண்ணையும் அச்சிட்டு, isFound to true என அமைக்கவும்.
      2. மூன்று உறுப்புகளின் கூட்டுத்தொகை தொகையை விட அதிகமாக இருந்தால் வேறு சரிபார்க்கவும்.
        1. உண்மை என்றால், k இன் மதிப்பை 1 குறைக்கவும்.
      3. மூன்று உறுப்புகளின் தொகை (தற்போதைய வரிசை கூறுகள்) தொகையை விட குறைவாக இருக்கிறதா என்று சோதிக்கவும்.
        1. உண்மை என்றால், j இன் மதிப்பை 1 ஆல் அதிகரிக்கவும்.
  4. IsFound தவறானதா என சரிபார்க்கவும், மூன்று மும்மூர்த்திகளை உருவாக்க முடியாது என்று முடிவு செய்கிறது.

விளக்கம்

நாம் சாப்பிடுவோம் வகையான மதிப்புகள் அதிகரிக்கும் வரிசையில் மாறுவதற்கான முதல் வரிசை, ஏனெனில் நாம் ஒரு பயன்படுத்தப் போகிறோம் பைனரி தேடல் அணுகுமுறை, கொஞ்சம். நாங்கள் ஒரு அறிவிக்கப் போகிறோம் பூலியன் மாறி முதலில் அதன் மதிப்பை பொய்யாக அமைக்கவும், மும்மடங்கைக் கண்டறிந்தவுடன் அதைப் புதுப்பிக்கப் போகிறோம். கொடுக்கப்பட்ட எண்ணுக்கு உறுப்புகளின் கூட்டுத்தொகைகளைக் கொண்ட மும்மூர்த்திகளில் எதையும் நாம் காணவில்லை எனில், மதிப்பு என்பது ஃபவுண்ட் அப்படியே உள்ளது, நாம் ஒரு மும்மடங்கைக் கண்டறிந்தால் மட்டுமே அதை உண்மைக்கு புதுப்பிக்கப் போகிறோம், எனவே இதனுடன் , எந்த மூவரும் காணப்படவில்லை என்று நாம் முடிவு செய்யலாம்.

வரிசையை வரிசைப்படுத்திய பின், உள்ளமைக்கப்பட்ட சுழற்சியில் தொடங்கி, வரிசையை n-1 ​​நீளம் வரை பயணிப்போம். மாறி மதிப்புகளில் ஒன்றை i + 1 ஆகவும், மற்றொரு மதிப்பு n-1 ஆகவும் அமைக்கிறது. உள் சுழற்சியில், ஒரு வரிசையின் அனைத்து மதிப்புகளையும் கடந்து செல்வோம், மேலும் கொடுக்கப்பட்ட எண் 'தொகை' மூன்று தற்போதைய வரிசை உறுப்புகளின் கூட்டுத்தொகைக்கு சமமாக இருக்கிறதா என்று சோதிப்போம் (arr [i] + arr [j] + arr [k ]) சமம் அல்லது இல்லை. நிபந்தனை திருப்தி அடைந்தால், ஒரு வரிசையின் தற்போதைய மதிப்புகள் அனைத்தையும் அச்சிடப் போகிறோம், அது உண்மைக்கு உண்மையான மதிப்பை அமைக்கிறோம், இது தவறான மதிப்பை திருப்பித் தரக்கூடாது என்பதை உறுதி செய்கிறது.

ஒரு வரிசையின் மூன்று தற்போதைய மதிப்புகளின் தொகை கொடுக்கப்பட்ட எண்ணுக்கு சமமாக இல்லாவிட்டால், மூன்று தற்போதைய உறுப்புகளின் கூட்டுத்தொகை கொடுக்கப்பட்ட தொகையை விடக் குறைவாக இருந்தால், தொகையை விடக் குறைவாக இருந்தால், மதிப்பை அதிகரிப்போம் j இன், இடதுபுறத்தில் இருந்து குறிக்கும் நமது இடது சுட்டிக்காட்டி என்று பொருள் குறுக்குவெட்டு அதிகரிப்பு மற்றும் இந்த நிபந்தனை கூட பூர்த்தி செய்யாவிட்டால், தொகையை விட தொகை அதிகமாக இருக்கிறதா என்று சோதிப்போம், உண்மை என்றால், k இன் மதிப்பைக் குறைப்போம்.

வரிசையின் அனைத்து மதிப்புகளும் கடந்து செல்லும் வரை இது தொடரும். நாம் isFound மதிப்பை திருப்பித் தரப் போகிறோம், இது மும்மூர்த்திகளில் ஏதேனும் ஒன்றைக் கண்டறிந்தால் உண்மை எனத் திருப்பித் தரலாம்.

நடைமுறைப்படுத்தல்

கொடுக்கப்பட்ட மதிப்பைக் குறிக்கும் அனைத்து தனித்துவமான மும்மூர்த்திகளுக்கான சி ++ நிரல்

#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” என்பது வரிசையில் உள்ள உறுப்புகளின் எண்ணிக்கை.

விண்வெளி சிக்கலானது

ஓ (n) எங்கே “N” என்பது வரிசையில் உள்ள உறுப்புகளின் எண்ணிக்கை.