આપેલ સમય લીટકોડ સોલ્યુશન પર હોમવર્ક કરતા વિદ્યાર્થીઓની સંખ્યા


મુશ્કેલી સ્તર સરળ
અરે

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

આપેલ સમય લીટકોડ સોલ્યુશન પર હોમવર્ક કરતા વિદ્યાર્થીઓની સંખ્યા

startTime = [1,2,3], endTime = [3,2,7], queryTime = 4
1

સમજૂતી: અમારી પાસે ત્રણ વિદ્યાર્થીઓ છે જેમાંથી ફક્ત 1 વિદ્યાર્થી ક્વેરી સમય દરમિયાન તેના હોમવર્ક પર કામ કરે છે. કારણ કે ત્યાં ફક્ત એક જ બાળક છે જેણે પોતાનું હોમવર્ક સમય = 3 પર શરૂ કરવું અને તે સમય = 7 પર પૂર્ણ કરવું.

startTime = [4], endTime = [4], queryTime = 4
1

સમજૂતી: આપણી પાસે એક જ વિદ્યાર્થી છે જે ક્વેરી સમયની જેમ જ તેના હોમવર્ક શરૂ કરે છે. આમ આઉટપુટ પણ 1 છે.

આપેલ સમય લીટકોડ સોલ્યુશનમાં હોમવર્ક કરતા વિદ્યાર્થીઓની સંખ્યા માટેનો અભિગમ

સમસ્યાએ અમને ક્વેરી સમય દરમિયાન તેમના હોમવર્ક પર કામ કરતા વિદ્યાર્થીઓની સંખ્યા શોધવા માટે પૂછ્યું. અમને વેક્ટરના રૂપમાં વિદ્યાર્થીઓની હોમવર્ક પ્રવૃત્તિઓની શરૂઆત અને અંતિમ સમય પ્રદાન કરવામાં આવે છે એરે. આ માહિતીનો ઉપયોગ કરીને, અમે જરૂરી મૂલ્ય શોધવાનો પ્રયાસ કરીએ છીએ.

ફક્ત આપેલ માહિતીને પાર પાડીને આપણે સરળતાથી સમસ્યા હલ કરી શકીએ છીએ. આપેલી માહિતી હોમવર્ક પ્રવૃત્તિની શરૂઆત અને અંતિમ સમય છે. તેથી અમે તપાસ કરીએ છીએ કે ક્વેરીનો સમય હોમવર્ક પ્રવૃત્તિની શરૂઆત અને અંતિમ સમય વચ્ચેનો છે. આ વિદ્યાર્થીઓની ગણતરી રાખવી એ પરિણામલક્ષી જવાબ આપે છે.

આપેલ સમય લીટકોડ સોલ્યુશનમાં હોમવર્ક કરતા વિદ્યાર્થીઓની સંખ્યા માટેનો કોડ

સી ++ કોડ

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

int busyStudent(vector<int> startTime, vector<int> endTime, int queryTime) {
    int n = startTime.size();
    int ans = 0;
    for(int i=0;i<n;i++)
        ans += ((startTime[i] <= queryTime && queryTime <= endTime[i]) ? 1 : 0);
    return ans;
}

int main(){
    vector<int> startTime = {4};
    vector<int> endTime = {4};
    int queryTime = 4;
    cout<<(busyStudent(startTime, endTime, queryTime));
}
1

જાવા કોડ

import java.util.*;
import java.lang.*;
import java.io.*;

class Main
{
  public static int busyStudent(int[] startTime, int[] endTime, int queryTime) {
        int n = startTime.length;
        int ans = 0;
        for(int i=0;i<n;i++)
            ans += ((startTime[i] <= queryTime && queryTime <= endTime[i]) ? 1 : 0);
        return ans;
    }
    
  public static void main (String[] args) throws java.lang.Exception
  {
    int[] startTime = {4};
    int[] endTime = {4};
    int queryTime = 4;
    System.out.println(busyStudent(startTime, endTime, queryTime));
  }
}
1

જટિલતા વિશ્લેષણ

સમય જટિલતા

ઓ (એન), કારણ કે આપણે બધા ઇનપુટ તત્વોને વટાવીએ છીએ. આમ સમય જટિલતા રેખીય હોવાનું બહાર આવે છે.

અવકાશ જટિલતા

ઓ (1), કારણ કે આપણે ગણતરીને સંગ્રહિત કરવા માટે ફક્ત એક જ ચલનો ઉપયોગ કરીએ છીએ.