ನಿರ್ದಿಷ್ಟ ಸಮಯದ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರದಲ್ಲಿ ಮನೆಕೆಲಸ ಮಾಡುವ ವಿದ್ಯಾರ್ಥಿಗಳ ಸಂಖ್ಯೆ


ತೊಂದರೆ ಮಟ್ಟ ಸುಲಭ
ಅರೇ

ಒಂದು ನಿರ್ದಿಷ್ಟ ಸಮಯದಲ್ಲಿ ಮನೆಕೆಲಸ ಮಾಡುವ ವಿದ್ಯಾರ್ಥಿಗಳ ಸಂಖ್ಯೆ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರವು ಒಂದು ನಿರ್ದಿಷ್ಟ ಸಮಯದಲ್ಲಿ ತಮ್ಮ ಮನೆಕೆಲಸದಲ್ಲಿ ಕೆಲಸ ಮಾಡುವ ವಿದ್ಯಾರ್ಥಿಗಳ ಸಂಖ್ಯೆಯನ್ನು ಕಂಡುಹಿಡಿಯಲು ಕೇಳುತ್ತದೆ. ಸಮಸ್ಯೆ ತುಂಬಾ ಸ್ಪಷ್ಟವಾಗಿದೆ, ಶೀರ್ಷಿಕೆಯು ಈಗಾಗಲೇ ಇಡೀ ಸಮಸ್ಯೆಯನ್ನು ವಿವರಿಸಲು ಸಮರ್ಥವಾಗಿದೆ. ನಮಗೆ ಪ್ರಶ್ನೆ ಸಮಯ ಮತ್ತು ವಿದ್ಯಾರ್ಥಿಗಳು ತಮ್ಮ ಮನೆಕೆಲಸದಲ್ಲಿ ಕೆಲಸ ಮಾಡುವ ಸಮಯವನ್ನು ನೀಡಲಾಗುತ್ತದೆ. ಆದ್ದರಿಂದ, ಈ ಮಾಹಿತಿಯನ್ನು ಬಳಸಿಕೊಂಡು ಪ್ರಶ್ನೆಯ ಸಮಯದಲ್ಲಿ ತಮ್ಮ ಮನೆಕೆಲಸ ಮಾಡುತ್ತಿರುವ ವಿದ್ಯಾರ್ಥಿಗಳ ಸಂಖ್ಯೆಯನ್ನು ಕಂಡುಹಿಡಿಯಲು ನಮ್ಮನ್ನು ಕೇಳಲಾಗುತ್ತದೆ. ಆದ್ದರಿಂದ, ಎಂದಿನಂತೆ ನೇರವಾಗಿ ದ್ರಾವಣಕ್ಕೆ ಹಾರಿ. ನಾವು ಕೆಲವು ಉದಾಹರಣೆಗಳನ್ನು ಪರಿಶೀಲಿಸೋಣ.

ನಿರ್ದಿಷ್ಟ ಸಮಯದ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರದಲ್ಲಿ ಮನೆಕೆಲಸ ಮಾಡುವ ವಿದ್ಯಾರ್ಥಿಗಳ ಸಂಖ್ಯೆ

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

ವಿವರಣೆ: ನಾವು ಮೂರು ವಿದ್ಯಾರ್ಥಿಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ, ಅದರಲ್ಲಿ ಕೇವಲ 1 ವಿದ್ಯಾರ್ಥಿ ಮಾತ್ರ ಅವನ / ಅವಳ ಮನೆಕೆಲಸವನ್ನು ಪ್ರಶ್ನೆಯ ಸಮಯದಲ್ಲಿ ಕೆಲಸ ಮಾಡುತ್ತಾನೆ. ಏಕೆಂದರೆ ಒಂದೇ ಮಗು ತನ್ನ ಮನೆಕೆಲಸವನ್ನು ಸಮಯ = 3 ಕ್ಕೆ ಪ್ರಾರಂಭಿಸುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಸಮಯ = 7 ಕ್ಕೆ ಪೂರ್ಣಗೊಳಿಸುತ್ತದೆ.

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

ಸಂಕೀರ್ಣತೆ ವಿಶ್ಲೇಷಣೆ

ಸಮಯ ಸಂಕೀರ್ಣತೆ

ಒ (ಎನ್), ನಾವು ಎಲ್ಲಾ ಇನ್ಪುಟ್ ಅಂಶಗಳನ್ನು ಹಾದುಹೋಗುವುದರಿಂದ. ಹೀಗಾಗಿ ಸಮಯದ ಸಂಕೀರ್ಣತೆಯು ರೇಖೀಯವಾಗಿ ಹೊರಬರುತ್ತದೆ.

ಬಾಹ್ಯಾಕಾಶ ಸಂಕೀರ್ಣತೆ

ಒ (1), ಏಕೆಂದರೆ ನಾವು ಎಣಿಕೆಯನ್ನು ಸಂಗ್ರಹಿಸಲು ಒಂದೇ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ.