C++ प्रोग्राम यह पता लगाने के लिए कि एक फिल्म समारोह में एक सहभागी पूरी तरह से कितनी फिल्में देख सकता है

मान लीजिए कि एक फिल्म समारोह चल रहा है जिसमें विभिन्न देशों की विभिन्न फिल्में प्रदर्शित होती हैं। अब, एक सहभागी उन फिल्मों की अधिकतम संख्या में भाग लेना चाहता है जो एक-दूसरे के साथ ओवरलैप नहीं होती हैं और हमें यह पता लगाने में उनकी मदद करनी होगी कि वे कितनी फिल्मों में भाग ले सकते हैं।

एक संरचना मूवी है जिसमें निम्नलिखित सदस्य हैं -

फिल्म की शुरुआत का समय।
फिल्म की अवधि।
फ़िल्म खत्म होने का समय.

निम्नलिखित सदस्यों के साथ एक और संरचना महोत्सव है -

उत्सव में फिल्मों की संख्या।
एक प्रकार की मूवी जिसका आकार उत्सव में फिल्मों की संख्या के समान है।

हमें फेस्टिवल ऑब्जेक्ट को दो सरणियों 'टाइमबीगिन' और 'अवधि' के साथ बनाना और आरंभ करना है जिसमें क्रमशः कई फिल्मों का प्रारंभ समय और अवधि शामिल है। एक पूर्णांक n फिल्मों की कुल संख्या को दर्शाता है और इसका उपयोग ऑब्जेक्ट को इनिशियलाइज़ करने के लिए भी किया जाता है। हम आगे उस ऑब्जेक्ट का उपयोग यह गणना करने के लिए करते हैं कि एक सहभागी कितनी फिल्में पूरी तरह से देख सकता है।

इसलिए, यदि इनपुट टाइमबीगिन ={1, 3, 0, 5, 5, 8, 8}, अवधि ={3, 2, 2, 4, 3, 2, 3}, n =7 जैसा है, तो आउटपुट 4 होगा

सहभागी उस उत्सव में पूरी तरह से कुल 4 फिल्में देख सकता है।

इसे हल करने के लिए, हम इन चरणों का पालन करेंगे -

स्ट्रक्चर मूवी {
- तीन सदस्य चर परिभाषित करें समयप्रारंभ, अवधि, समयअंत
- एक ऑपरेटर '<' को ओवरलोड करें, यह एक मूवी टाइप वेरिएबल को दूसरा ले जाएगा।
  - वापसी का समय समाप्ति <अन्य समय समाप्त
स्ट्रक्चर फेस्टिवल {
- सदस्य संख्या परिभाषित करें
- ऐरे मूवी को परिभाषित करें जिसमें मूवी प्रकार का आइटम हो
एक फंक्शन इनिशियलाइज़ () को परिभाषित करें। इसमें सरणियों का समय लगेगाशुरुआत और समयअंत और एक iteger n।
- filmFestival :=एक नई महोत्सव वस्तु
- फ़िल्मफ़ेस्टिवल की गिनती:=गिनती
- इनिशियलाइज़ i :=0 के लिए, जब मैं <गिनता हूँ, अपडेट करता हूँ (i 1 से बढ़ाएँ), −
  - अस्थायी:=मूवी प्रकार की एक नई वस्तु
  - अस्थायी का समय प्रारंभ:=समयप्रारंभ[i]
  - अस्थायी की अवधि:=अवधि[i]
  - अस्थायी का समय समाप्ति:=समय शुरू[i] + अवधि[i]
  - फ़िल्मफ़ेस्टिवल की सरणी फ़िल्मों में अस्थायी डालें
- फिल्मोत्सव पर लौटें
एक फ़ंक्शन को परिभाषित करें हल करें (), यह महोत्सव प्रकार का एक चर उत्सव लेगा,
- res :=0
- उत्सव की फिल्मों को क्रमबद्ध करें
- समय समाप्ति :=-1
- इनिशियलाइज़ i :=0 के लिए, जब i
  काउंट, अपडेट (i से 1 तक बढ़ाएँ), करें −
  - अगर समय फिल्मों की शुरुआत[i] उत्सव का>=समयअंत, फिर −
    - (रेस 1 से बढ़ाएँ)
    - समय समाप्त:=फिल्मों का समय[i] उत्सव का
- रिटर्न रेस

उदाहरण

आइए बेहतर समझ पाने के लिए निम्नलिखित कार्यान्वयन देखें -

#include<bits/stdc++.h>

using namespace std;

struct Movie {
   int timeBegin, duration, timeEnd;
   bool operator<(const Movie& another) const {
      return timeEnd < another.timeEnd;
   }
};

struct Festival {
   int count;
   vector<Movie> movies;
};
Festival* initialize(int timeBegin[], int duration[], int count) {
   Festival* filmFestival = new Festival;
   filmFestival->count = count;
   for (int i = 0; i < count; i++) {
      Movie temp;
      temp.timeBegin = timeBegin[i];
      temp.duration = duration[i];
      temp.timeEnd = timeBegin[i] + duration[i];
      filmFestival->movies.push_back(temp);
   }
   return filmFestival;
}
int solve(Festival* fest) {
   int res = 0;
   sort(fest->movies.begin(), fest->movies.end());
   int timeEnd = -1;
   for (int i = 0; i < fest->count; i++) {
      if (fest->movies[i].timeBegin >= timeEnd) {
         res++;
            timeEnd = fest->movies[i].timeEnd;
      }
   }
   return res;
}

int main(int argc, char *argv[]) {
int timeBegin[] = {1, 3, 0, 5, 5, 8, 8};
int duration[] = {3, 2, 2, 4, 3, 2, 3};
Festival * fest;
fest = initialize(timeBegin,duration, 7);
cout << solve(fest) << endl;
return 0;
}

इनपुट

int timeBegin[] = {1, 3, 0, 5, 5, 8, 8};
int duration[] = {3, 2, 2, 4, 3, 2, 3};
Festival * fest;
fest = initialize(timeBegin,duration, 7);