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

C++ में कर्मचारी फ्री टाइम

मान लीजिए हमें कर्मचारियों की शेड्यूल की एक सूची दी गई है; यह प्रत्येक कर्मचारी के लिए कार्य समय का प्रतिनिधित्व करता है। अब मान लीजिए प्रत्येक कर्मचारी के पास नॉन-ओवरलैपिंग अंतराल की एक सूची है, ये अंतराल सॉर्टेड हैं। हमें सभी कर्मचारियों के लिए सामान्य, पॉजिटिव-लेंथ फ्री टाइम का प्रतिनिधित्व करने वाले परिमित अंतराल की सूची ज्ञात करनी है, और वह भी सॉर्टेड ऑर्डर में होगी। हम अंतराल को [x, y] के रूप में दर्शा रहे हैं, उदाहरण के लिए, schedule[0][0].start = 1, schedule[0][0].end = 2।

तो, यदि इनपुट schedule = [[[1,2],[5,6]],[[1,3]],[[4,10]]] है, तो आउटपुट में से एक [[3,4]] होगा।

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

  • एक 2D ऐरे v परिभाषित करें

  • i := 0 से शुरू करें, जब i < schedule का आकार, अपडेट करें (i को 1 से बढ़ाएं), करें:

    • j := 0 से शुरू करें, जब j < schedule[i] का आकार, अपडेट करें (j को 1 से बढ़ाएं), करें:

      • schedule[i, j] को v के अंत में डालें

  • ऐरे v को सॉर्ट करें

  • एक 2D ऐरे ret परिभाषित करें

  • एक ऐरे टेम्प := v[0] परिभाषित करें

  • i := 0 से शुरू करें, जब i < v का आकार, अपडेट करें (i को 1 से बढ़ाएं), करें:

    • यदि टेम्प[0] < v[i, 1], तो:

      • {टेम्प[1], v[i, 0]} को ret के अंत में डालें

      • टेम्प := v[i]

    • अन्यथा:

      • टेम्प := (यदि टेम्प[1] < v[i, 1], तो v[i], अन्यथा टेम्प)

  • ret लौटाएं

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

उदाहरण

#include <bits/stdc++.h>
using namespace std;

void print_vector(vector> v) {
    cout << "[";
    for(int i = 0; i < v.size(); i++) {
        cout << "[";
        for(int j = 0; j < v[i].size(); j++) {
            cout << v[i][j] << ", ";
        }
        cout << "],";
    }
    cout << "]" << endl;
}

class Solution {
public:
    static bool cmp(vector a, vector b) {
        return a[0] < b[0];
    }

    vector> employeeFreeTime(vector>> schedule) {
        vector> v;
        for (int i = 0; i < schedule.size(); i++) {
            for (int j = 0; j < schedule[i].size(); j++) {
                v.push_back(schedule[i][j]);
            }
        }
        sort(v.begin(), v.end(), cmp);
        vector> ret;
        vector temp = v[0];
        for (int i = 0; i < v.size(); i++) {
            if (temp[0] < v[i][1]) {
                ret.push_back({temp[1], v[i][0]});
                temp = v[i];
            } else {
                temp = temp[1] < v[i][1] ? v[i] : temp;
            }
        }
        return ret;
    }
};

int main() {
    Solution ob;
    vector>> v = {{{1,2},{5,6}},{{1,3}},{{4,10}}};
    print_vector(ob.employeeFreeTime(v));
}

इनपुट

{{{1,2},{5,6}},{{1,3}},{{4,10}}}

आउटपुट

[[2, 1, ],[2, 1, ],[3, 4, ],[10, 5, ],]
  1. - C++ में अगला निकटतम समय

    मान लीजिए हमारे पास HH:MM प्रारूप में दर्शाया गया एक समय है, हमें वर्तमान अंकों का पुन: उपयोग करके अगला निकटतम समय उत्पन्न करना है। हम अंक का असीमित संख्या में उपयोग कर सकते हैं। उदाहरण के लिए, यदि इनपुट 19:34 है, तो आउटपुट 19:39 होगा क्योंकि अंकों 1, 9, 3, 4 से अगला निकटतम समय 19:39 है। यह 19:33 न

  1. - C++ में अद्वितीय भिन्नों की सूची

    मान लीजिए हमारे पास भिन्नों की एक सूची है जहां प्रत्येक भिन्न में [अंश, हर] (अंश / हर) होता है। हमें भिन्नों की एक नई सूची ज्ञात करनी है जैसे कि भिन्नों में संख्याएँ: अपने सबसे सरल रूप में हों (20/14, 10/7 बन जाता है)। कोई भी डुप्लिकेट भिन्न (सरल करने के बाद) हटा दिए जाएं। उनके वास्तवि

  1. C/C++ में बर्कले का एल्गोरिथ्म C/C++ में बर्कले का एल्गोरिथ्म

    बर्कले का एल्गोरिथ्म वितरित प्रणालियों में क्लॉक सिंक्रोनाइज़ेशन के लिए उपयोग किया जाने वाला एक एल्गोरिथ्म है। यह एल्गोरिथ्म उन मामलों में उपयोग किया जाता है जब वितरित नेटवर्क के कुछ या सभी सिस्टम में निम्नलिखित समस्याएं होती हैं: A. मशीन के पास सटीक समय स्रोत नहीं है। B. नेटवर्क या मशीन के पास UTC