AP గా ఏర్పడే క్రమబద్ధీకరించిన శ్రేణిలో అన్ని ముగ్గులను ముద్రించండి


కఠినత స్థాయి మీడియం
తరచుగా అడుగుతుంది యాక్సెంచర్ అకోలైట్ కాడెన్స్ ఇండియా గూగుల్ ఇన్ఫోఎడ్జ్ Intuit Pinterest
అర్రే హాష్ శోధించండి

“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)

వివరణ

ఇవన్నీ AP గా ఏర్పడే ముగ్గులు

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

వివరణ

ఇవన్నీ AP గా ఏర్పడే ముగ్గులు

అల్గారిథం

  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 తగ్గించండి.

వివరణ

మేము ఒక ఇచ్చాము క్రమబద్ధీకరించబడింది అమరిక. అంకగణిత పురోగతిని ఏర్పరుచుకునే అన్ని ముగ్గులను కనుగొనమని మేము అడుగుతాము. అంకగణిత పురోగతిని సంఖ్య శ్రేణిగా నిర్వచించవచ్చు, దీనిలో అన్ని అంశాలు వరుసగా వాటి మధ్య ఒక నిర్దిష్ట దూరంతో వరుసగా వస్తాయి. AP యొక్క సూత్రం ద్వారా మేము ముగ్గురిని కనుగొంటాము, ఇది + c = 2b అని పేర్కొంటుంది, అంటే రెండు సంఖ్యల మొత్తం మూడవ సంఖ్యకు రెండు రెట్లు సమానంగా ఉంటే.

లూప్ మరియు ఎ కోసం ఒకదానితో మొత్తం శ్రేణిని ప్రయాణించండి లూప్ అయితే, 'అయితే లూప్' మూడు మూలకాలు AP ను ఏర్పరుస్తాయా లేదా అని మేము కనుగొంటాము. మేము ఫర్ లూప్ గుండా ప్రయాణించినప్పుడల్లా j యొక్క విలువను i విలువ కంటే తక్కువ మరియు k యొక్క విలువ i విలువ కంటే ఒకటికి సెట్ చేస్తాము. ఇది మనకు తనిఖీ చేయడానికి ఒక మూలకాన్ని ఎంచుకుంటుంది, కాబట్టి ప్రతిసారీ మనకు ar [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

జావా కోడ్ AP గా ఏర్పడే క్రమబద్ధీకరించిన శ్రేణిలో అన్ని ముగ్గులను ముద్రించండి

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 యొక్క మూలకాలను కనుగొనడానికి ఉపయోగించబడుతుంది.

అంతరిక్ష సంక్లిష్టత

O (1) అదనపు స్థలం అవసరం లేదు.