ਸਭ ਤੋਂ ਹੌਲੀ ਕੀ ਲੀਟਕੋਡ ਹੱਲ


ਮੁਸ਼ਕਲ ਪੱਧਰ ਸੌਖੀ
ਅਕਸਰ ਪੁੱਛਿਆ ਜਾਂਦਾ ਹੈ ਐਮਾਜ਼ਾਨ
ਅਰੇ

ਸਮੱਸਿਆ ਦਾ ਸਭ ਤੋਂ ਹੌਲੀ ਕੀ ਲੀਟਕੋਡ ਹੱਲ ਸਾਨੂੰ ਕੁੰਜੀਆਂ ਦਾ ਇੱਕ ਸਿਲਸਿਲਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ ਜੋ ਦਬਾਈਆਂ ਜਾਂਦੀਆਂ ਹਨ. ਸਾਨੂੰ ਇੱਕ ਵੀ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ ਐਰੇ ਜਾਂ ਸਮੇਂ ਦੇ ਵੈਕਟਰ, ਇਹ ਕੁੰਜੀਆਂ ਜਾਰੀ ਕੀਤੀਆਂ ਗਈਆਂ ਹਨ. ਕੁੰਜੀਆਂ ਦਾ ਕ੍ਰਮ ਇੱਕ ਸਤਰ ਦੇ ਰੂਪ ਵਿੱਚ ਦਿੱਤਾ ਗਿਆ ਹੈ. ਇਸ ਲਈ, ਸਮੱਸਿਆ ਨੇ ਸਾਨੂੰ ਹੌਲੀ ਕੁੰਜੀ ਲੱਭਣ ਲਈ ਕਿਹਾ, ਜੋ ਕਿ ਕੰਮ ਕਰਨ ਵਿਚ ਸਭ ਤੋਂ ਲੰਬਾ ਸਮਾਂ ਲੈਂਦੀ ਹੈ. ਕੁੰਜੀ ਦੁਆਰਾ ਕੰਮ ਕਰਨ ਜਾਂ ਟਾਈਪ ਕਰਨ ਲਈ ਲਿਆ ਗਿਆ ਸਮਾਂ ਮੌਜੂਦਾ ਕੁੰਜੀ ਅਤੇ ਪਿਛਲੀ ਕੁੰਜੀ ਲਈ ਜਾਰੀ ਕੀਤੇ ਗਏ ਸਮੇਂ ਦਾ ਅੰਤਰ ਹੈ ਜੋ ਦਬਾਇਆ ਗਿਆ ਹੈ. ਜੇ ਅਸੀਂ ਦੋ ਜਾਂ ਦੋ ਤੋਂ ਵੱਧ ਕੁੰਜੀਆਂ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਾਂ ਜੋ ਇਕੋ ਸਮੇਂ ਲੈਂਦੇ ਹਨ. ਇਸ ਲਈ ਅਸੀਂ ਉਹ ਕੁੰਜੀ ਵਾਪਸ ਕਰਦੇ ਹਾਂ ਜੋ ਕਿ ਸ਼ਬਦ-ਕੋਸ਼ ਦੇ ਅਨੁਸਾਰ ਸਭ ਤੋਂ ਵੱਡੀ ਹੈ. ਘੋਲ ਨੂੰ ਡੂੰਘਾਈ ਨਾਲ ਡੁੱਬਣ ਤੋਂ ਪਹਿਲਾਂ, ਆਓ ਪਹਿਲਾਂ ਕੁਝ ਉਦਾਹਰਣਾਂ 'ਤੇ ਗੌਰ ਕਰੀਏ.

ਸਭ ਤੋਂ ਹੌਲੀ ਕੀ ਲੀਟਕੋਡ ਹੱਲ

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

ਵਿਆਖਿਆ: ਹਰੇਕ ਕੁੰਜੀ ਦੁਆਰਾ ਲਿਆ ਗਿਆ ਸਮਾਂ 9, 20, 20, 1. ਹੈ. ਇਹ ਰੀਲਿਜ਼ ਸਮਾਂ ਕ੍ਰਮਵਾਰ c, b, c, ਅਤੇ d ਲਈ ਹਨ. ਕਿਉਂਕਿ ਕੁੰਜੀਆਂ b ਅਤੇ c ਲਈ ਰੀਲਿਜ਼ ਦਾ ਸਮਾਂ ਇਕੋ ਜਿਹਾ ਹੈ. ਅਸੀਂ ਸ਼ਬਦਕੋਸ਼ ਦੀ ਸਭ ਤੋਂ ਵੱਡੀ ਕੁੰਜੀ ਵਾਪਸ ਕਰਦੇ ਹਾਂ ਜੋ ਸੀ.

ਹੌਲੀ ਕੀ ਲੀਟਕੋਡ ਹੱਲ ਲਈ ਪਹੁੰਚ

ਸਮੱਸਿਆ ਦਾ ਸਭ ਤੋਂ ਹੌਲੀ ਕੀ ਲੀਟਕੋਡ ਹੱਲ ਪਹਿਲਾਂ ਹੀ ਉੱਪਰ ਦੱਸਿਆ ਗਿਆ ਹੈ. ਸੰਖੇਪ ਵਿੱਚ, ਸਮੱਸਿਆ ਨੇ ਸਾਨੂੰ ਇੱਕ ਕੁੰਜੀ ਲੱਭਣ ਲਈ ਕਿਹਾ ਹੈ ਜੋ ਚੱਲਣ ਵਿੱਚ ਸਭ ਤੋਂ ਲੰਮੀ ਕਿਸਮ ਦੀ ਹੁੰਦੀ ਹੈ. ਜੇ ਸਥਿਤੀ ਵਿੱਚ, ਦੋ ਜਾਂ ਵਧੇਰੇ ਕੁੰਜੀਆਂ ਨੂੰ ਚਲਾਉਣ ਲਈ ਇੱਕੋ ਜਿਹਾ ਸਮਾਂ ਲੱਗਦਾ ਹੈ. ਫਿਰ ਸਾਨੂੰ ਸ਼ਬਦਕੋਸ਼ ਦੀ ਸਭ ਤੋਂ ਵੱਡੀ ਕੁੰਜੀ ਵਾਪਸ ਕਰਨ ਦੀ ਲੋੜ ਹੈ. ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ, ਅਸੀਂ ਸਿਰਫ ਦਬਾਈਆਂ ਗਈਆਂ ਕੁੰਜੀਆਂ ਨੂੰ ਪਾਰ ਕਰਦੇ ਹਾਂ ਅਤੇ ਹਰੇਕ ਕੁੰਜੀ ਦੇ ਰੀਲਿਜ਼ ਸਮੇਂ ਦਾ ਮੁਲਾਂਕਣ ਕਰਦੇ ਹਾਂ. ਪਹਿਲੀ ਕੁੰਜੀ ਲਈ ਇਹ ਰੀਲਿਜ਼ ਟਾਈਮ [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), ਕਿਉਂਕਿ ਅਸੀਂ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਸਿਰਫ ਦੋ ਵਾਧੂ ਪਰਿਵਰਤਨ ਦੀ ਵਰਤੋਂ ਕੀਤੀ.