एक सरणी गिरफ्तारी [] और एक पूर्णांक k इनपुट के रूप में दिया गया है। लक्ष्य arr[] की उप-सरणी की संख्या ज्ञात करना है, जैसे कि उस उप-सरणी के तत्वों का गुणनफल k से विभाज्य हो।
उदाहरण के लिए
इनपुट
arr[] = {2, 1, 5, 8} k=4 आउटपुट
Count of sub-arrays whose product is divisible by k are: 4
स्पष्टीकरण
The subarrays will be: [ 8 ], [ 5,8 ], [ 1,5,8 ], [ 2,1,5,8 ].
इनपुट
arr[] = {7,1,9,7} k=9 आउटपुट
Count of sub−arrays whose product is divisible by k are: 6
स्पष्टीकरण
The subarrays will be: [ 9 ], [ 9,7 ], [ 1,9 ], [ 1,9,7 ], [ 7,1,9 ], [ 7,1,9,7 ].
नीचे दिए गए कार्यक्रम में उपयोग किया गया दृष्टिकोण इस प्रकार है -
निष्पक्ष दृष्टिकोण
हम दो दृष्टिकोणों का उपयोग करके इस समस्या को हल करेंगे। भोले दृष्टिकोण में, बस लूप के लिए दो का उपयोग करके सरणी को पार करें और अनुक्रमित i और j के बीच प्रत्येक उप-सरणी के लिए जांचें कि क्या तत्वों का उत्पाद k से विभाज्य है। यदि हाँ तो वेतन वृद्धि की गणना करें।
-
इनपुट के रूप में एक पूर्णांक सरणी arr[] और k लें।
-
फ़ंक्शन product_k(int arr[], int size, int k) एक सरणी और k लेता है और उप-सरणी का एक गिनती देता है जिसका उत्पाद k से विभाज्य है।
-
प्रारंभिक गणना को इनपुट के रूप में लें।
-
i=0 से i<आकार और j=i से j<आकार तक ट्रैवर्स गिरफ्तारी। और k=i से k<=j
-
प्रत्येक उपसरणी गिरफ्तारी [i से j] के लिए, गिरफ्तारी [k] को अस्थायी से गुणा करें।
-
यदि उत्पाद का तापमान k से विभाज्य है तो वृद्धि की गणना।
-
तीनों लूप के अंत में, परिणाम के रूप में वापसी की गणना करें।
कुशल दृष्टिकोण
इस दृष्टिकोण में, प्रत्येक उप-सरणी को पार करने के बजाय, हम उत्पादों को सेगमेंट ट्री में संग्रहीत करेंगे। अब इस पेड़ के उत्पादों का उपयोग करें जो k से विभाज्य हैं। और तदनुसार वेतन वृद्धि।
-
इनपुट के रूप में एक पूर्णांक सरणी arr[] और k लें।
-
हम सेगमेंट ट्री को एक सरणी arr_2[4 * size_2] के रूप में लागू करेंगे।
-
फ़ंक्शन set_in(int fit, int first, int last, const int* arr, int k) उत्पादों के लिए सेगमेंट ट्री बनाने के लिए उपयोग किया जाता है।
-
फंक्शन चेक (इंट फिट, इंट फर्स्ट, इंट लास्ट, इंट स्टार्ट, इंट एंड, इंट के) का उपयोग स्टार्ट और एंड के बीच सबरे के उत्पाद को खोजने के लिए किया जाता है।
-
अगर पहला>आखिरी या पहला>अंत या आखिरी<स्टार्ट रिटर्न 1.
-
अगर पहला>=आखिरी और आखिरी<=अंत तो वापस arr_2[fir]%k.
-
स्तर सेट करें=प्रथम+अंतिम>> 1 (2 से विभाजित करें)।
-
अब लेवल और लेवल+1 के लिए रिकर्सिव कॉल चेक() और सेट_1 और सेट_2 में स्टोर करें।
-
गिनती =सेट_1+सेट_2 और वापसी गणना सेट करें।
-
फ़ंक्शन product_k(int arr[], int size, int k) arr[] और k लेता है और उप-सरणी की गिनती देता है जिसका उत्पाद k से विभाज्य है।
-
प्रारंभिक गणना 0 के रूप में लें।
-
आरंभिक गणना को 0 के रूप में सेट करें।
-
i=0 से i<आकार और j=0 से j<आकार तक दो लूप का उपयोग करके ट्रैवर्स करें। Settemp=check(1, 0, size - 1, i, j, k).
-
अगर यह टेम्परेचर 0 है तो इंक्रीमेंट काउंट।
-
अंतिम परिणाम के रूप में वापसी की गणना।
उदाहरण
#include <bits/stdc++.h>
using namespace std;
int product_k(int arr[], int size, int k){
int count = 0;
for (int i = 0; i < size; i++){
for (int j = i; j < size; j++){
int temp = 1;
for (int k = i; k <= j; k++){
temp = temp * arr[k];
}
if(temp % k == 0){
count++;
}
}
}
return count;
}
int main(){
int arr[] = {2, 1, 5, 8, 10, 12 };
int size = sizeof(arr) / sizeof(arr[0]);
int k = 2;
cout<<"Count of sub−arrays whose product is divisible by k are: "<<product_k(arr, size, k);
return 0;
} आउटपुट
यदि हम उपरोक्त कोड चलाते हैं तो यह निम्न आउटपुट उत्पन्न करेगा -
Count of sub−arrays whose product is divisible by k are: 18
उदाहरण (कुशल दृष्टिकोण)
#include <bits/stdc++.h>
using namespace std;
#define size_2 100002
int arr_2[4 * size_2];
void set_in(int fit, int first, int last, const int* arr, int k){
if (first == last){
arr_2[fit] = (1LL * arr[first]) % k;
return;
}
int level = (first + last) >> 1;
set_in(2 * fit, first, level, arr, k);
set_in(2 * fit + 1, level + 1, last, arr, k);
arr_2[fit] = (arr_2[2 * fit] * arr_2[2 * fit + 1]) % k;
}
int check(int fit, int first, int last, int start, int end, int k){
if(first > last){
return 1;
}
if(first > end){
return 1;
}
if(last < start){
return 1;
}
if (first >= start){
if(last <= end){
return arr_2[fit] % k;
}
}
int level = (first + last) >> 1;
int set_1 = check(2 * fit, first, level, start, end, k);
int set_2 = check(2 * fit + 1, level + 1, last, start, end, k);
int count = (set_1 * set_2) % k;
return count;
}
int product_k(int arr[], int size, int k){
int count = 0;
for (int i = 0; i < size; i++){
for (int j = i; j < size; j++){
int temp = check(1, 0, size − 1, i, j, k);
if (temp == 0){
count++;
}
}
}
return count;
}
int main(){
int arr[] = {2, 1, 5, 8, 10, 12};
int size = sizeof(arr) / sizeof(arr[0]);
int k = 2;
set_in(1, 0, size − 1, arr, k);
cout<<"Count of sub−arrays whose product is divisible by k are: "<<product_k(arr, size, k);
return 0;
} आउटपुट
यदि हम उपरोक्त कोड चलाते हैं तो यह निम्न आउटपुट उत्पन्न करेगा -
Count of sub−arrays whose product is divisible by k are: 18