ਕੂਕੀਜ਼ ਲੀਟਕੋਡ ਸਲਿ .ਸ਼ਨ ਨਿਰਧਾਰਤ ਕਰੋ


ਮੁਸ਼ਕਲ ਪੱਧਰ ਸੌਖੀ
ਅਕਸਰ ਪੁੱਛਿਆ ਜਾਂਦਾ ਹੈ ਐਮਾਜ਼ਾਨ
ਲਾਲਚੀ

ਸਮੱਸਿਆ ਕੂਕੀਜ਼ ਨਿਰਧਾਰਤ ਕਰੋ ਲੀਟਕੋਡ ਹੱਲ ਦੋ ਐਰੇ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ. ਓਨ੍ਹਾਂ ਵਿਚੋਂ ਇਕ ਐਰੇ ਕੂਕੀਜ਼ ਦੇ ਆਕਾਰ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ ਅਤੇ ਦੂਜਾ ਬੱਚਿਆਂ ਦੇ ਲਾਲਚ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ. ਸਮੱਸਿਆ ਦੱਸਦੀ ਹੈ ਕਿ ਤੁਸੀਂ ਬੱਚਿਆਂ ਦੇ ਮਾਪੇ ਹੋ, ਅਤੇ ਤੁਸੀਂ ਚਾਹੁੰਦੇ ਹੋ ਕਿ ਬੱਚਿਆਂ ਦੀ ਅਧਿਕਤਮ ਸੰਖਿਆ ਸੰਤੁਸ਼ਟ ਹੋਵੇ. ਤੁਸੀਂ ਇਕ ਬੱਚੇ ਨੂੰ ਸਿਰਫ ਇਕ ਕੁਕੀ ਦੇ ਸਕਦੇ ਹੋ. ਬੱਚਿਆਂ ਦੀ ਵੱਧ ਤੋਂ ਵੱਧ ਗਿਣਤੀ ਲੱਭੋ. ਆਓ ਪਹਿਲਾਂ ਕੁਝ ਉਦਾਹਰਣਾਂ ਲਈਏ.

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

ਵਿਆਖਿਆ: ਸਾਡੇ ਕੋਲ ਅਕਾਰ 1 ਦੀਆਂ ਦੋ ਕੂਕੀਜ਼ ਹਨ, ਅਤੇ ਤਿੰਨ ਬੱਚਿਆਂ ਦੇ ਵੱਖੋ ਵੱਖਰੇ ਸਮੱਗਰੀ ਮੁੱਲ ਹਨ. ਅਸੀਂ ਸਿਰਫ ਬੱਚਿਆਂ ਦੀ ਇਕੋ ਸਮੱਗਰੀ ਬਣਾ ਸਕਦੇ ਹਾਂ ਜਿਸਦੀ ਲਾਲਚੀ ਕੀਮਤ 1 ਹੈ. ਕਿਉਂਕਿ ਦੋਵੇਂ ਦੋ ਬੱਚਿਆਂ ਨੂੰ ਵੱਡੀਆਂ ਕੂਕੀਜ਼ ਦੀ ਜ਼ਰੂਰਤ ਹੈ.

ਕੂਕੀਜ਼ ਲੀਟਕੋਡ ਸਲਿ .ਸ਼ਨ ਨਿਰਧਾਰਤ ਕਰੋ

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

ਵਿਆਖਿਆ: ਅਸੀਂ ਦੋਵਾਂ ਬੱਚਿਆਂ ਨੂੰ ਸੰਤੁਸ਼ਟੀ ਮਹਿਸੂਸ ਕਰ ਸਕਦੇ ਹਾਂ ਕਿਉਂਕਿ ਕੂਕੀਜ਼ ਜੋ ਸਾਡੇ ਕੋਲ ਹਨ ਉਹ ਲੋੜੀਂਦੇ ਆਕਾਰ ਦੇ ਬਰਾਬਰ ਜਾਂ ਬਰਾਬਰ ਹਨ. ਇਸ ਤਰ੍ਹਾਂ ਆਉਟਪੁਟ 2 ਹੈ.

ਅਸਾਈਨ ਕੂਕੀਜ਼ ਲੀਟਕੋਡ ਸਲਿ .ਸ਼ਨ ਲਈ ਪਹੁੰਚ

ਸਮੱਸਿਆ ਨਿਰਧਾਰਤ ਕਰੋ ਕੂਕੀਜ਼ ਲੀਟਕੋਡ ਸਲਿ contentਸ਼ਨ ਸਾਨੂੰ ਬੱਚਿਆਂ ਨੂੰ ਵੱਧ ਤੋਂ ਵੱਧ ਸਮਗਰੀ ਲੱਭਣ ਲਈ ਕਹਿੰਦਾ ਹੈ ਜੇ ਅਸੀਂ ਕਿਸੇ ਬੱਚੇ ਨੂੰ ਸਿਰਫ ਇਕੋ ਕੁਕੀ ਦੇ ਸਕਦੇ ਹਾਂ. ਇਸ ਲਈ ਸਭ ਤੋਂ ਵਧੀਆ ਪਹੁੰਚ ਹੈ ਲਾਲਚ ਨਾਲ ਘੱਟੋ ਘੱਟ ਲਾਲਚੀ ਬੱਚੇ ਨੂੰ ਸਭ ਤੋਂ ਛੋਟੀਆਂ ਕੂਕੀਜ਼ ਨਾਲ ਸੰਤੁਸ਼ਟ ਮਹਿਸੂਸ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਨਾ ਜੋ ਕਿ ਵਰਤੀਆਂ ਜਾ ਸਕਦੀਆਂ ਹਨ. ਇਸ ਲਈ, ਇਸ ਪ੍ਰਕਿਰਿਆ ਦੀ ਨਕਲ ਕਰਨ ਲਈ ਅਸੀਂ ਦੋਵੇਂ ਦਿੱਤੀਆਂ ਐਰੇ ਨੂੰ ਕ੍ਰਮਬੱਧ ਕਰਦੇ ਹਾਂ ਅਤੇ ਬੱਚਿਆਂ ਨੂੰ ਕੂਕੀਜ਼ ਨਿਰਧਾਰਤ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹਾਂ. ਜੇ ਅਸੀਂ ਮੌਜੂਦਾ ਕੂਕੀ ਨੂੰ ਮੌਜੂਦਾ ਬੱਚੇ ਨੂੰ ਨਿਰਧਾਰਤ ਨਹੀਂ ਕਰ ਸਕਦੇ ਤਾਂ ਅਸੀਂ ਅਗਲੀ ਕੂਕੀ ਨੂੰ ਉਦੋਂ ਤਕ ਅਜ਼ਮਾਉਂਦੇ ਹਾਂ ਜਦੋਂ ਤੱਕ ਅਸੀਂ ਮੌਜੂਦਾ ਬੱਚੇ ਨੂੰ ਸੰਤੁਸ਼ਟ ਨਹੀਂ ਕਰਦੇ. ਕਿਉਂਕਿ ਜੇ ਅਸੀਂ ਮੌਜੂਦਾ ਬੱਚੇ ਨੂੰ ਸੰਤੁਸ਼ਟ ਨਹੀਂ ਕਰ ਸਕਦੇ, ਤਾਂ ਅਸੀਂ ਮੌਜੂਦਾ ਬੱਚਿਆਂ ਨੂੰ ਮੌਜੂਦਾ ਕੂਕੀ ਨਾਲ ਸੰਤੁਸ਼ਟ ਨਹੀਂ ਕਰ ਸਕਦੇ.

ਕੋਡ

ਅਸਾਈਨ ਕੂਕੀਜ਼ ਲੀਟਕੋਡ ਹੱਲ ਲਈ ਸੀ ++ ਕੋਡ

#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

ਜਟਿਲਤਾ ਵਿਸ਼ਲੇਸ਼ਣ

ਟਾਈਮ ਜਟਿਲਤਾ

ਓ (ਐਨਲੌਗ ਐਨ), ਦਿੱਤੇ ਗਏ ਐਰੇ ਨੂੰ ਕ੍ਰਮਬੱਧ ਕਰਨ ਲਈ ਸਮੇਂ ਦੇ ਕਾਰਨ. ਇੱਥੇ ਐਨ ਦਿੱਤੀਆਂ ਹੋਈਆਂ ਐਰੇ ਵਿੱਚ ਐਲੀਮੈਂਟਸ ਦੀ ਗਿਣਤੀ ਦਰਸਾਉਂਦਾ ਹੈ.

ਸਪੇਸ ਦੀ ਜਟਿਲਤਾ

ਓ (ਐਨਲੌਗ ਐਨ), ਦਿੱਤੇ ਗਏ ਐਰੇ ਨੂੰ ਕ੍ਰਮਬੱਧ ਕਰਨ ਲਈ ਲੋੜੀਂਦੀ ਜਗ੍ਹਾ ਦੇ ਕਾਰਨ. ਦੁਬਾਰਾ ਐਨ ਐਰੇ ਵਿਚਲੇ ਤੱਤਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ.