AP ஐ உருவாக்கும் வரிசைப்படுத்தப்பட்ட வரிசையில் அனைத்து மும்மூர்த்திகளையும் அச்சிடுக


சிரமம் நிலை நடுத்தர
அடிக்கடி கேட்கப்படுகிறது அக்சன்சர் அகோலைட் காடென்ஸ் இந்தியா கூகிள் தகவல் எட்ஜ் intuit இடுகைகள்
அணி ஹாஷ் தேடி

“AP ஐ உருவாக்கும் வரிசைப்படுத்தப்பட்ட வரிசையில் அனைத்து மும்மூர்த்திகளையும் அச்சிடு” என்ற சிக்கல், நாங்கள் ஒரு வரிசைப்படுத்தப்பட்டதைக் கூறுகிறோம் முழு வரிசை. எண்கணித முன்னேற்றத்தை உருவாக்கக்கூடிய அனைத்து மும்மூர்த்திகளையும் கண்டுபிடிப்பதே பணி.

AP ஐ உருவாக்கும் வரிசைப்படுத்தப்பட்ட வரிசையில் அனைத்து மும்மூர்த்திகளையும் அச்சிடுக

உதாரணமாக

arr[] = {1,3,5,7,8,12,15,16,20,30}
(1, 3, 5), (3, 5, 7), (1, 8, 15), (8, 12, 16), (12, 16, 20)

விளக்கம்

இவை அனைத்தும் ஒரு ஆந்திரத்தை உருவாக்கும் மும்மூர்த்திகள்

arr[] = {2,4,5,6,9,14,18,24}
(2, 4, 6), (4, 5, 6), (4, 9, 14), (4, 14, 24)

விளக்கம்

இவை அனைத்தும் ஒரு ஆந்திரத்தை உருவாக்கும் மும்மூர்த்திகள்

அல்காரிதம்

  1. இருந்து சுழற்சி i = 1 முதல் n-1 வரை(சேர்க்கப்படவில்லை).
  2. J இன் மதிப்பை i ஐ விடக் குறைவாகவும், k இன் மதிப்பு i ஐ விடவும் ஒன்றாகவும் அமைக்கவும்.
  3. போது j> = 0 && k <n.
    1. இரண்டு தற்போதைய வரிசை உறுப்புகளின் கூட்டுத்தொகை மற்ற வரிசை உறுப்புக்கு இருமடங்காக இருக்கிறதா என்று சோதிக்கவும்,
      1. உண்மை என்றால், தற்போதைய மூன்று கூறுகளை அச்சிட்டு முறையே k மற்றும் j இன் மதிப்பைக் குறைத்து அதிகரிக்கவும்.
    2. இரண்டு உறுப்புகளின் கூட்டுத்தொகை மற்றொரு உறுப்புக்கு இரண்டு மடங்கு குறைவாக இருக்கிறதா என்று சோதிக்கவும், பின்னர், k ஐ 1 ஆல் அதிகரிக்கவும்.
    3. இரண்டு உறுப்புகளின் கூட்டுத்தொகை மற்றொரு உறுப்பை விட இரண்டு மடங்கு அதிகமாக இருக்கிறதா என்று சரிபார்க்கவும், பின்னர், j ஐ 1 ஆகக் குறைக்கவும்.

விளக்கம்

நாங்கள் ஒரு கொடுத்துள்ளோம் வரிசைப்படுத்தப்பட்ட வரிசை. எண்கணித முன்னேற்றத்தை உருவாக்கக்கூடிய அனைத்து மும்மூர்த்திகளையும் கண்டுபிடிக்கும்படி கேட்கப்படுகிறோம். ஒரு எண்கணித முன்னேற்றத்தை ஒரு எண் வரிசையாக வரையறுக்கலாம், இதில் அனைத்து கூறுகளும் தொடர்ச்சியாக முழு வரிசையிலும் அவற்றுக்கு இடையே ஒரு குறிப்பிட்ட தூரத்துடன் வருகின்றன. ஒரு + சி = 2 பி என்று குறிப்பிடும் ஒரு AP இன் சூத்திரத்தால் மும்மடங்கைக் காண்போம், அதாவது இரண்டு எண்களின் கூட்டுத்தொகை மூன்றாவது எண்ணின் இரு மடங்கிற்கு சமமாக இருந்தால்.

முழு வரிசையையும் லூப் மற்றும் ஒரு உடன் பயணிக்கவும் லூப் போது, 'அதே நேரத்தில் லூப்' மூன்று உறுப்புகள் AP ஐ உருவாக்க முடியுமா இல்லையா என்பதை நாங்கள் சோதிக்கப் போகிறோம். ஃபார் லூப் வழியாக நாம் பயணிக்கும்போதெல்லாம், j இன் மதிப்பை i இன் மதிப்பை விடவும், k இன் மதிப்பை i இன் மதிப்பை விடவும் ஒன்றுக்கு அமைப்போம். இது சரிபார்க்க எங்களுக்கு ஒரு உறுப்பை எடுக்கும், எனவே ஒவ்வொரு முறையும் arr [i], arr [j] மற்றும் arr [k] ஐ சரிபார்க்க மூன்று கூறுகள் உள்ளன, ஒவ்வொன்றிற்கும் மாறுபடும் i, j, மற்றும் k இன் மதிப்பு சுழற்சியாக இருந்தாலும் சரி, உள்ளே இருந்தாலும் சரி லூப் போது.

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

குறியீடு

AP ஐ உருவாக்கும் வரிசைப்படுத்தப்பட்ட வரிசையில் அனைத்து மும்மூர்த்திகளையும் அச்சிட C ++ குறியீடு

#include<iostream>

using namespace std;

void getTripletsWithAP(int arr[], int n)
{
  for (int i = 1; i < n - 1; i++)
  {
    int j = i - 1, k = i + 1;
        while(j >= 0 && k < n)
        {
            if (arr[j] + arr[k] == 2 * arr[i])
            {
        cout <<arr[j]<< " "<<arr[i]<<" "<<arr[k]<< endl;
                k++;
                j--;
            }
            else if (arr[j] + arr[k] < 2 * arr[i])
                k++;
            else
                j--;
        }
  }
}
int main()
{
  int arr[] = {1,3,5,7,8,12,15,16,20,30};
  int n = sizeof(arr) / sizeof(arr[0]);
  getTripletsWithAP(arr, n);
  return 0;
}
1 3 5
3 5 7
1 8 15
8 12 16
12 16 20

ஜாவா குறியீடு அனைத்து மும்மூர்த்திகளையும் வரிசைப்படுத்தப்பட்ட வரிசையில் அச்சிடும்

class TripletAP
{
    public static void getTripletsWithAP(int arr[], int n)
    {
        for (int i = 1; i < n - 1; i++)
        {
            int j = i - 1, k = i + 1;
            while(j >= 0 && k < n)
            {
                if (arr[j] + arr[k] == 2 * arr[i])
                {
                    System.out.println(arr[j] +" " +arr[i]+ " " + arr[k]);
                    k++;
                    j--;
                }
                else if (arr[j] + arr[k] < 2 * arr[i])
                    k++;
                else
                    j--;
            }
        }
    }
    public static void main (String[] args)
    {
        int arr[] = {1,3,5,7,8,12,15,16,20,30};
        int n = arr.length;
        getTripletsWithAP(arr, n);
    }
}
1 3 5
3 5 7
1 8 15
8 12 16
12 16 20

சிக்கலான பகுப்பாய்வு

நேர சிக்கலானது

ஓ (என்2எங்கே “N”  என்பது வரிசையில் உள்ள உறுப்புகளின் எண்ணிக்கை. ஏனென்றால் எங்களிடம் இரண்டு உள்ளமை வளையங்கள் உள்ளன, அங்கு முதல் வளையமானது நாம் முடிவை அடையும் வரை இயங்கும், பின்னர் இரண்டாவது உள்ளமை வளையம் AP இன் கூறுகளைக் கண்டறியப் பயன்படுகிறது.

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

ஓ (1) கூடுதல் இடம் தேவையில்லை என்பதால்.