నెమ్మదిగా కీ లీట్‌కోడ్ పరిష్కారం  


కఠినత స్థాయి సులువు
తరచుగా అడుగుతుంది అమెజాన్
అల్గోరిథంలు అర్రే కోడింగ్ ఇంటర్వ్యూ ఇంటర్వ్యూ ప్రిపరేషన్ లీట్‌కోడ్ LeetCodeSolutions

నెమ్మదిగా ఉన్న కీ లీట్‌కోడ్ సొల్యూషన్ సమస్య మనకు నొక్కిన కీల శ్రేణిని అందిస్తుంది. మాకు కూడా ఇవ్వబడింది అమరిక లేదా ఈ కీలు విడుదల చేయబడిన వెక్టర్. కీల క్రమం స్ట్రింగ్ రూపంలో ఇవ్వబడుతుంది. కాబట్టి, నెమ్మదిగా ఉన్న కీని కనుగొనమని సమస్య మమ్మల్ని కోరింది, ఇది పని చేయడానికి ఎక్కువ సమయం పడుతుంది. పని చేయడానికి లేదా టైప్ చేయడానికి కీ తీసుకున్న సమయం ప్రస్తుత కీ మరియు మునుపటి కీ కోసం విడుదల చేసిన సమయాల తేడా. ఒకవేళ మేము ఒకే సమయం తీసుకునే రెండు లేదా అంతకంటే ఎక్కువ కీలను చూస్తాము. కాబట్టి మేము లెక్సికోగ్రాఫికల్గా అతిపెద్ద కీని తిరిగి ఇస్తాము. ద్రావణంలో లోతుగా డైవింగ్ చేయడానికి ముందు, మొదట కొన్ని ఉదాహరణలను పరిశీలిద్దాం.

నెమ్మదిగా కీ లీట్‌కోడ్ పరిష్కారంపిన్

releaseTimes = [9,29,49,50], keysPressed = "cbcd"
"c"

వివరణ: ప్రతి కీలు తీసుకున్న సమయం 9, 20, 20, 1. ఈ విడుదల సమయాలు వరుసగా సి, బి, సి మరియు డి కీల కోసం. బి మరియు సి కీల విడుదల సమయం ఒకే విధంగా ఉంటుంది కాబట్టి. మేము లెక్సికోగ్రాఫికల్గా అతిపెద్ద కీని తిరిగి ఇస్తాము.

నెమ్మదిగా కీ లీట్‌కోడ్ పరిష్కారం కోసం విధానం  

నెమ్మదిగా ఉన్న కీ లీట్‌కోడ్ పరిష్కారం ఇప్పటికే పైన వివరించబడింది. క్లుప్తంగా, అమలు చేయడానికి ఎక్కువ సమయం తీసుకునే కీని కనుగొనమని సమస్య మమ్మల్ని కోరింది. ఒకవేళ, రెండు లేదా అంతకంటే ఎక్కువ కీలు అమలు చేయడానికి ఒకే సమయాన్ని తీసుకుంటాయి. అప్పుడు మేము లెక్సికోగ్రాఫికల్గా అతిపెద్ద కీని తిరిగి ఇవ్వాలి. సమస్యను పరిష్కరించడానికి, మేము నొక్కిన కీలపై ప్రయాణించి, ప్రతి కీ కోసం విడుదల సమయాన్ని అంచనా వేస్తాము. మొదటి కీ కోసం ఇది రిలీజ్ టైమ్ [0] కు సమానం, ఆపై అది రిలీజ్ టైమ్ [i] - రిలీజ్ టైమ్ [i-1]. కాబట్టి మేము రెండు వేరియబుల్స్ ఉంచుతాము, ఒకటి జవాబును నిల్వ చేస్తుంది మరియు మరొకటి ఆ కీని అమలు చేయడానికి సమయం పడుతుంది.

ఇది కూడ చూడు
ఒక సబ్‌రే పర్వతం రూపంలో ఉందో లేదో కనుగొనండి

మేము కీల మీద ప్రయాణించి, వాటిలో ప్రతి విడుదల సమయాన్ని అంచనా వేస్తాము. ప్రస్తుత సమాధానం కంటే ఎక్కువ సమయం తీసుకునే లేదా లెక్సికోగ్రాఫికల్ గా పెద్దదిగా ఉన్న కీని కనుగొన్నప్పుడు మేము జవాబును నవీకరిస్తాము మరియు అమలు చేయడానికి అదే సమయం పడుతుంది. చివరికి, సమాధానం కాలింగ్ ఫంక్షన్‌కు తిరిగి వస్తుంది.

నెమ్మదిగా కీ లీట్‌కోడ్ పరిష్కారం కోసం కోడ్  

సి ++ కోడ్

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

char slowestKey(vector<int>& releaseTimes, string keysPressed) {
    int time = releaseTimes[0];
    char ans = keysPressed[0];
    for(int i=1;i<keysPressed.length();i++){
        int cur_time = releaseTimes[i] - releaseTimes[i-1];
        if(cur_time >= time){
            if(cur_time > time)
                ans = keysPressed[i], time = cur_time;
            else
                ans = max(ans, keysPressed[i]);
        }
    }
    return ans;
}

int main(){
    vector<int> releaseTimes = {9, 29, 49, 50};
    string keysPressed = "cbcd";
    cout<<slowestKey(releaseTimes, keysPressed);
}
c

జావా కోడ్

import java.util.*;
import java.lang.*;
import java.io.*;
 
class Main
{
  public static char slowestKey(int[] releaseTimes, String keysPressed) {
        int time = releaseTimes[0];
        char ans = keysPressed.charAt(0);
        for(int i=1;i<keysPressed.length();i++){
            int cur_time = releaseTimes[i] - releaseTimes[i-1];
            if(cur_time >= time){
                if(cur_time > time){
                    ans = keysPressed.charAt(i);
                    time = cur_time;
                }
                else
                    ans = ans > keysPressed.charAt(i) ? ans : keysPressed.charAt(i);
            }
        }
        return ans;
    }
 
  public static void main (String[] args) throws java.lang.Exception {
    int[] releaseTimes = {9, 29, 49, 50};
      String keysPressed = "cbcd";
      System.out.print(slowestKey(releaseTimes, keysPressed));
  }
}
c

సంక్లిష్టత విశ్లేషణ  

సమయం సంక్లిష్టత

పై), ఎందుకంటే ఇచ్చిన అన్ని కీల మీదుగా ప్రయాణించారు.

అంతరిక్ష సంక్లిష్టత

ఓ (1), ఎందుకంటే సమస్యను పరిష్కరించడానికి మేము రెండు అదనపు వేరియబుల్స్ మాత్రమే ఉపయోగించాము.

1