कुकीज़ Leetcode समाधान असाइन करें


कठिनाई स्तर आसान
में अक्सर पूछा वीरांगना
लालची

कुकीज़ लेटेकोड समाधान असाइन करें समस्या दो सरणियों के साथ प्रदान करता है। निम्न में से एक सरणियों कुकीज़ के आकार का प्रतिनिधित्व करता है और दूसरा बच्चों के लालच का प्रतिनिधित्व करता है। समस्या बताती है कि आप बच्चों के माता-पिता हैं, और आप चाहते हैं कि अधिकतम संख्या में बच्चे संतुष्ट रहें। आप केवल एक बच्चे को एक कुकी दे सकते हैं। सामग्री बच्चों की अधिकतम संख्या ज्ञात करें। पहले कुछ उदाहरण लेते हैं।

g = [1,2,3], s = [1,1]
1

स्पष्टीकरण: हमारे पास प्रत्येक आकार के दो कुकीज़ हैं, और विभिन्न सामग्री मूल्यों वाले तीन बच्चे हैं। हम केवल एक ही बच्चे की सामग्री बना सकते हैं जिसमें लालची मूल्य 1 है। चूंकि अन्य दो बच्चों को बड़े कुकीज़ की आवश्यकता होती है।

कुकीज़ Leetcode समाधान असाइन करें

g = [1,2], s = [1,2,3]
2

स्पष्टीकरण: हम दोनों बच्चों को सामग्री महसूस करा सकते हैं क्योंकि हमारे पास जो कुकीज़ हैं वे आवश्यक आकारों से अधिक या बराबर हैं। इस प्रकार आउटपुट 2 है।

कुकीज़ लेटेकोड समाधान असाइन करने के लिए दृष्टिकोण

कुकीज़ असाइन करें Leetcode Solution की समस्या बताती है कि अगर हम एक बच्चे को केवल एक ही कुकी दे सकते हैं, तो अधिकतम सामग्री बच्चों को खोजने के लिए कहें। इस प्रकार सबसे अच्छा तरीका यह है कि लालची बच्चे को कम से कम लालची बच्चे को सबसे छोटी कुकी के साथ संतुष्ट महसूस कराने की कोशिश करें जिसका उपयोग किया जा सकता है। इसलिए, इस प्रक्रिया को अनुकरण करने के लिए, हम दिए गए सरणियों को क्रमबद्ध करते हैं और बच्चों को कुकीज़ असाइन करने का प्रयास करते हैं। यदि हम वर्तमान कुकी को वर्तमान बच्चे को असाइन नहीं कर सकते हैं, तो हम अगले कुकी को तब तक आज़माते हैं जब तक हम वर्तमान बच्चे को संतुष्ट नहीं करते। क्योंकि यदि हम वर्तमान बच्चे को संतुष्ट नहीं कर सकते हैं, तो हम अगले बच्चों को वर्तमान कुकी से संतुष्ट नहीं कर सकते हैं।

कोड

सी + कोड असाइन कुकीज़ Leetcode समाधान के लिए

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

int findContentChildren(vector<int>& g, vector<int>& s) {
    sort(g.begin(), g.end());
    sort(s.begin(), s.end());
    int numberOfChildren = g.size(), numberOfCookies = s.size();
    int cookie = 0, answer = 0;
    for(int i=0;i<numberOfChildren && cookie<numberOfCookies;){
        if(s[cookie] >= g[i]){
            i++;
            answer++;
        }
        cookie++;
    }
    return answer;
}

int main(){
    vector<int> g = {1, 2, 3};
    vector<int> s = {1, 1};

    cout<<findContentChildren(g, s);
}
1

कुकीज़ कोड लेटकोड सॉल्यूशन के लिए जावा कोड

import java.util.*;
import java.lang.*;
import java.io.*;
 
class Ideone
{
    public static int findContentChildren(int[] g, int[] s) {
        Arrays.sort(g);
        Arrays.sort(s);
        int numberOfChildren = g.length;
        int numberOfCookies = s.length;
        int cookie = 0, answer = 0;
        for(int i=0;i<numberOfChildren && cookie<numberOfCookies;){
            if(s[cookie] >= g[i]){
                i++;
                answer++;
            }
            cookie++;
        }
        return answer;
    }
 
  public static void main (String[] args) throws java.lang.Exception
  {
    int[] g = {1, 2, 3};
    int[] s = {1, 1};
 
    System.out.println(findContentChildren(g, s));
  }
}
1

जटिलता विश्लेषण

समय जटिलता

O (NlogN), दिए गए सरणियों को सॉर्ट करने के लिए आवश्यक समय की वजह से। यहाँ N दिए गए सरणियों में तत्वों की संख्या का प्रतिनिधित्व करता है।

अंतरिक्ष जटिलता

O (NlogN), अंतरिक्ष की वजह से दिए गए सरणियों को सॉर्ट करने के लिए आवश्यक है। फिर एन सरण में तत्वों की संख्या का प्रतिनिधित्व करता है।