ഒരു നിശ്ചിത സമയ ലീട്ട്‌കോഡ് പരിഹാരത്തിൽ ഗൃഹപാഠം ചെയ്യുന്ന വിദ്യാർത്ഥികളുടെ എണ്ണം


വൈഷമ്യ നില എളുപ്പമായ
അറേ

ഒരു നിശ്ചിത സമയത്ത് ഗൃഹപാഠം ചെയ്യുന്ന വിദ്യാർത്ഥികളുടെ എണ്ണം ഒരു നിശ്ചിത സമയത്ത് അവരുടെ ഗൃഹപാഠത്തിൽ പ്രവർത്തിക്കുന്ന വിദ്യാർത്ഥികളുടെ എണ്ണം കണ്ടെത്താൻ ലീറ്റ്കോഡ് പരിഹാരം ഞങ്ങളോട് ആവശ്യപ്പെടുന്നു. പ്രശ്നം വളരെ വ്യക്തമാണ്, ശീർഷകത്തിന് ഇതിനകം തന്നെ മുഴുവൻ പ്രശ്നങ്ങളും വിശദീകരിക്കാൻ കഴിയും. ഞങ്ങൾക്ക് ഒരു ചോദ്യ സമയവും വിദ്യാർത്ഥികൾ അവരുടെ ഗൃഹപാഠത്തിൽ പ്രവർത്തിക്കുന്ന സമയവും നൽകിയിരിക്കുന്നു. അതിനാൽ, ഈ വിവരം ഉപയോഗിച്ച് അന്വേഷണ സമയത്ത് അവരുടെ ഗൃഹപാഠം ചെയ്യുന്ന വിദ്യാർത്ഥികളുടെ എണ്ണം കണ്ടെത്താൻ ഞങ്ങൾ ആവശ്യപ്പെടുന്നു. അതിനാൽ, പരിഹാരത്തിലേക്ക് നേരിട്ട് ചാടുന്നതിന് മുമ്പ് പതിവുപോലെ. നമുക്ക് കുറച്ച് ഉദാഹരണങ്ങൾ പരിശോധിക്കാം.

ഒരു നിശ്ചിത സമയ ലീട്ട്‌കോഡ് പരിഹാരത്തിൽ ഗൃഹപാഠം ചെയ്യുന്ന വിദ്യാർത്ഥികളുടെ എണ്ണം

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

വിശദീകരണം: ഞങ്ങൾക്ക് മൂന്ന് വിദ്യാർത്ഥികളുണ്ട്, അതിൽ ഒരു വിദ്യാർത്ഥി മാത്രമാണ് അവന്റെ / അവളുടെ ഗൃഹപാഠത്തിൽ അന്വേഷണ സമയത്ത് പ്രവർത്തിക്കുന്നത്. കാരണം ഒരു കുട്ടി മാത്രമേ ഗൃഹപാഠം ആരംഭിക്കുന്നു = 1, അത് സമയം = 3 പൂർത്തിയാക്കുന്നു.

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

വിശദീകരണം: അന്വേഷണ സമയത്തിന് സമാനമായി അവന്റെ / അവളുടെ ഗൃഹപാഠം ആരംഭിക്കുന്ന ഒരൊറ്റ വിദ്യാർത്ഥി ഞങ്ങളുടെ പക്കലുണ്ട്. അങ്ങനെ output ട്ട്‌പുട്ടും 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

സങ്കീർണ്ണത വിശകലനം

സമയ സങ്കീർണ്ണത

O (N), എല്ലാ ഇൻപുട്ട് ഘടകങ്ങളും ഞങ്ങൾ സഞ്ചരിക്കുന്നതിനാൽ. അങ്ങനെ സമയ സങ്കീർണ്ണത രേഖീയമായി പുറത്തുവരുന്നു.

ബഹിരാകാശ സങ്കീർണ്ണത

O (1), കാരണം, എണ്ണം സംഭരിക്കാൻ ഞങ്ങൾ ഒരൊറ്റ വേരിയബിൾ മാത്രമേ ഉപയോഗിക്കുന്നുള്ളൂ.