કૂકીઝ લીટકોડ સોલ્યુશન સોંપો


મુશ્કેલી સ્તર સરળ
વારંવાર પૂછવામાં આવે છે એમેઝોન
લોભી

સમસ્યા કૂકીઝ સોંપો લીટકોડ સોલ્યુશન બે એરે પ્રદાન કરે છે. આ પૈકી એક એરે કૂકીઝનું કદ રજૂ કરે છે અને બીજું બાળકોની લોભાનું પ્રતિનિધિત્વ કરે છે. સમસ્યા જણાવે છે કે તમે બાળકોના માતાપિતા છો, અને તમે બાળકોની મહત્તમ સંખ્યામાં સંતોષ માગો છો. તમે બાળકને ફક્ત એક કૂકી આપી શકો છો. બાળકોની મહત્તમ સંખ્યા શોધો. ચાલો પહેલા થોડા ઉદાહરણો લઈએ.

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

સમજૂતી: અમારી પાસે કદ 1 ની બે કૂકીઝ છે, અને ત્રણ બાળકો વિવિધ સામગ્રી મૂલ્યોવાળા છે. અમે ફક્ત એક જ બાળ સામગ્રી બનાવી શકીએ છીએ જેમાં લોભી મૂલ્ય 1. છે. કારણ કે અન્ય બે બાળકોને મોટી કૂકીઝની જરૂર છે.

કૂકીઝ લીટકોડ સોલ્યુશન સોંપો

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

સમજૂતી: અમે બંને બાળકોને સામગ્રીનો અહેસાસ કરી શકીએ છીએ કારણ કે આપણી પાસે જે કૂકીઝ છે તે જરૂરી કદના કરતા વધારે અથવા બરાબર છે. આમ આઉટપુટ 2 છે.

સોંપેલ કૂકીઝ લીટકોડ સોલ્યુશન માટે અભિગમ

કૂકીઝ સોંપો સમસ્યા, લેટકોડ સોલ્યુશન અમને બાળકોને ફક્ત એક જ કૂકી આપી શકીએ તો, બાળકોની મહત્તમ સંખ્યા શોધવા માટે પૂછે છે. આ રીતે શ્રેષ્ઠ અભિગમ એ છે કે લોભીથી ઓછામાં ઓછા લોભી બાળકને ઉપયોગમાં લઈ શકાય તેવી સૌથી નાની કૂકીમાં સંતોષની લાગણી થાય. તેથી, આ પ્રક્રિયાનું અનુકરણ કરવા માટે અમે આપેલ બંને એરેને સ sortર્ટ કરીએ છીએ અને બાળકોને કૂકીઝ સોંપવાનો પ્રયત્ન કરીએ છીએ. જો આપણે વર્તમાન કૂકીને વર્તમાન બાળકને સોંપી ન શકીએ તો આપણે વર્તમાન બાળકને સંતોષ ન કરીએ ત્યાં સુધી અમે આગલી કૂકીનો પ્રયત્ન કરીશું. કારણ કે જો આપણે વર્તમાન બાળકને સંતોષ ન આપી શકીએ, તો અમે વર્તમાન કૂકીથી આગામી બાળકોને સંતોષ આપી શકતા નથી.

કોડ

સોંપેલ કૂકીઝ લીટકોડ સોલ્યુશન માટે સી ++ કોડ

#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), આપેલ એરેને સ sortર્ટ કરવા માટે જરૂરી સમય હોવાને કારણે. અહીં એન આપેલ એરેમાં તત્વોની સંખ્યા રજૂ કરે છે.

અવકાશ જટિલતા

O (NlogN), આપેલ એરેને સ sortર્ટ કરવા માટે જરૂરી જગ્યાને કારણે. ફરીથી એન એરેમાં તત્વોની સંખ્યા રજૂ કરે છે.