Computer >> कंप्यूटर >  >> प्रोग्रामिंग >> C++

C++ में सभी संभावित उप-सरणियों के बीच न्यूनतम LCM और GCD संभव है

मान लीजिए कि हमारे पास आकार N का एक सरणी है। इसमें N धनात्मक संख्याएँ हैं। हमें सभी संभावित उप-सरणी के न्यूनतम तत्वों को खोजना होगा। मान लीजिए कि सरणी {2, 66, 14, 521} है, तो न्यूनतम LCM 2 है, और GCD 1 है।

हम लालची दृष्टिकोण का उपयोग करके इस समस्या का समाधान करेंगे। यदि हम तत्वों की संख्या घटाते हैं, तो LCM कम होगा, और यदि हम सरणी का आकार बढ़ाते हैं, तो GCD कम होगा। हमें सरणी से सबसे छोटा तत्व खोजने की आवश्यकता है, जो कि एक एकल तत्व है, जिसे LCM की आवश्यकता होगी। जीसीडी के लिए, जीसीडी सरणी के सभी तत्वों का जीसीडी होगा।

उदाहरण

#include <iostream>
#include <algorithm>
using namespace std;
int minimum_gcd(int arr[], int n) {
   int GCD = 0;
   for (int i = 0; i < n; i++)
   GCD = __gcd(GCD, arr[i]);
   return GCD;
}
int minimum_lcm(int arr[], int n) {
   int LCM = arr[0];
   for (int i = 1; i < n; i++)
   LCM = min(LCM, arr[i]);
   return LCM;
}
int main() {
   int arr[] = { 2, 66, 14, 521 };
   int n = sizeof(arr) / sizeof(arr[0]);
   cout << "LCM: " << minimum_lcm(arr, n) << ", GCD: " << minimum_gcd(arr, n);
}

आउटपुट

LCM: 2, GCD: 1

  1. C++ में सरणी के न्यूनतम और अधिकतम तत्वों को खोजने के लिए पुनरावर्ती कार्यक्रम

    हमें इनपुट के रूप में एक पूर्णांक सरणी Arr[] दी गई है। लक्ष्य पुनरावर्ती विधियों का उपयोग करके सरणी के बीच अधिकतम और न्यूनतम तत्वों को खोजना है। चूंकि हम रिकर्सन का उपयोग कर रहे हैं, हम पूरे सरणी को तब तक पार करेंगे जब तक हम लंबाई =1 तक नहीं पहुंच जाते हैं, फिर ए [0] लौटाते हैं जो बेस केस बनाता है।

  1. न्यूनतम संख्या C++ में ट्री के सभी नोड्स को सूचना पास करने के लिए पुनरावृत्तियों की संख्या

    हमें n नोड्स की संख्या के साथ एक ट्री डेटा संरचना दी गई है। दिए गए पेड़ में एक रूट नोड और संबंधित बच्चे होंगे जो कि कोई भी संख्या हो सकती है और आगे के बच्चे के कितने भी बच्चे हो सकते हैं। कार्य एक पेड़ के सभी नोड्स को जानकारी पास करने के लिए एक पेड़ के रूट नोड द्वारा आवश्यक पुनरावृत्तियों की न्यूनतम

  1. सी++ में एक पेड़ में सभी सेबों को इकट्ठा करने का न्यूनतम समय

    मान लीजिए कि हमारे पास एक अप्रत्यक्ष पेड़ है जिसमें n शीर्ष हैं और इनकी संख्या 0 से n-1 तक है, जिसके शीर्षों में कुछ सेब हैं। हम पेड़ के एक किनारे पर चलने में 1 सेकंड खर्च करते हैं। पेड़ में सभी सेबों को शीर्ष 0 से शुरू करने और इस शीर्ष पर वापस आने के लिए हमें सेकंड में न्यूनतम समय निकालना होगा। यह