एपी की गणना (अंकगणितीय प्रगति) सी ++ में एक सरणी में अनुक्रम

एक सरणी एआर [] को देखते हुए जिसमें पूर्णांक तत्व होते हैं। लक्ष्य गिरफ्तारी [] के अंदर अंकगणितीय प्रगति के बाद की संख्या की गणना करना है। arr[] के अंदर तत्वों की श्रेणी [1,1000000] हैं।

खाली अनुक्रम या एकल तत्व भी गिना जाएगा।

आइए उदाहरणों से समझते हैं।

उदाहरण के लिए

इनपुट - गिरफ्तारी [] ={1,2,3}

आउटपुट - एपी की गणना (अंकगणितीय प्रगति) एक सरणी में परवर्ती हैं:8

स्पष्टीकरण - निम्नलिखित परवर्ती एपी बनेंगे:-

{}, {1}, {2}, {3}, {1,2}, {2,3}, {1,3}, {1,2,3}

इनपुट - गिरफ्तारी [] ={2,4,5,8}

आउटपुट - एपी की संख्या (अंकगणितीय प्रगति) एक सरणी में परवर्ती हैं:12

स्पष्टीकरण - निम्नलिखित परवर्ती एपी बनेंगे:-

{}, {2}, {4}, {5}, {8}, {2,4}, {2,5}, {2,8}, {4,5}, {4,8}, { 5,8}, {2,5,8}

नीचे दिए गए प्रोग्राम में इस्तेमाल किया गया तरीका इस प्रकार है

• खाली अनुक्रम भी एक एपी है।
• एकल मान भी AP होता है।
• सरणी में न्यूनतम और अधिकतम मान max_val और min_val के रूप में खोजें। सभी एपी बाद में सामान्य अंतर [ min_val - max_val , max_val - min_val ]
के बीच होंगे
• अब प्रत्येक सामान्य अंतर के लिए हम डायनेमिक प्रोग्रामिंग का उपयोग करते हुए बाद में पाएंगे और arr_2[size] में स्टोर करेंगे।
• लंबाई 2 या 2 से अधिक का कोई भी अनुवर्ती arr_2[i]-1 का योग नहीं होगा जहां i [0,2] है और अंतर D है।
• arr_2[i] =1+ योग ( arr[j] ) जहां i
• तेजी से दृष्टिकोण के लिए arr_3[max_size]
में रकम जोड़ें ( arr_2[j] arr[j]+D =arr[i] और jइनपुट के रूप में पूर्णांक सरणी arr[] लें।
• फ़ंक्शन AP_subsequence(int arr[], int size) एक इनपुट सरणी लेता है और एक सरणी में AP (अंकगणितीय प्रगति) बाद की संख्या देता है।
• प्रारंभिक गणना 0 के रूप में लें।
• अनुक्रमों की गणना के लिए चर max_val, min_val, arr_2[size] लें और रकम जमा करने के लिए arr_3[max_size] लें।
• ट्रैवर्स arr[] लूप के लिए उपयोग करके और अधिकतम और न्यूनतम तत्व ढूंढें और max_val और min_val में स्टोर करें।
• एकल तत्व APs और खाली AP के लिए गिनती =आकार +1 लें।
• अधिकतम अंतर की गणना करें diff_max =max_val - min_val और diff_min =min_val - max_val सामान्य अंतर संभव के रूप में।
• लूप का उपयोग करके j=0 से j<आकार तक ट्रैवर्स करें।
• arr_2[j] =1 सेट करें;
• गिरफ्तारी के लिए[j] - i>=1 और arr[j] - i <=1000000 सेट arr_2[j] +=arr_3[arr[j] - i].
• गिनने के लिए arr_2[j]-1 जोड़ें।
• अपडेट योग को arr_3[arr[j]] =arr_3[arr[j]] + arr_2[j] के रूप में करें।
• अंत में परिणाम के रूप में वापसी की गणना करें।

#include<bits/stdc++.h>

using namespace std;
#define max_size 10000

int AP_subsequence(int arr[], int size) {
   int count = 0;
   int max_val = INT_MAX;
   int min_val = INT_MIN;
   int arr_2[size];
   int arr_3[max_size];

   for (int i = 0; i < size; i++) {
      max_val = min(max_val, arr[i]);
      min_val = max(min_val, arr[i]);
   }
   count = size + 1;
   int diff_max = max_val - min_val;
   int diff_min = min_val - max_val;
   for (int i = diff_max; i <= diff_min; i++) {
      memset(arr_3, 0, sizeof arr_3);
      for (int j = 0; j < size; j++) {
         arr_2[j] = 1;
         if (arr[j] - i >= 1) {
            if (arr[j] - i <= 1000000) {
               arr_2[j] += arr_3[arr[j] - i];
            }
         }
         count += arr_2[j] - 1;
         arr_3[arr[j]] = arr_3[arr[j]] + arr_2[j];
      }
   }
   return count;
}
int main() {
   int arr[] = {1,1,6,7,8};
   int size = sizeof(arr) / sizeof(arr[0]);
   cout << "Count of AP (Arithmetic Progression) Subsequences in an array are: " << AP_subsequence(arr, size);
   return 0;
}

Count of AP (Arithmetic Progression) Subsequences in an array are: 17