මන්දගාමී යතුරු ලීට්කෝඩ් විසඳුම


දුෂ්කරතා මට්ටම පහසු
නිතර අසනු ලැබේ ඇමේසන්
අරා

මන්දගාමී යතුරු ලීට්කෝඩ් විසඳුම මඟින් එබූ යතුරු මාලාවක් අපට සපයයි. අපට ද ලබා දී ඇත අරාව හෝ මෙම යතුරු මුදා හරින ලද දෛශිකය. යතුරු අනුක්‍රමය නූලක ස්වරූපයෙන් දක්වා ඇත. ඉතින්, ගැටළුව අපෙන් ඉල්ලා සිටියේ මන්දගාමී යතුර සොයා ගැනීමටය, එය ක්‍රියා කිරීමට දීර් est තම කාලය ගතවේ. ක්‍රියා කිරීමට හෝ ටයිප් කිරීමට යතුර විසින් ගත කරන කාලය වත්මන් යතුර සඳහා මුදා හැරීමේ වේලාවන් සහ එබූ පෙර යතුරේ වෙනස වේ. එකම වේලාවක් ගතවන යතුරු දෙකක් හෝ වැඩි ගණනක් අපට හමු වුවහොත්. එබැවින් අපි ශබ්දකෝෂ විද්‍යාත්මකව විශාලතම යතුර නැවත ලබා දෙමු. විසඳුම ගැඹුරට කිමිදීමට පෙර, අපි පළමුව උදාහරණ කිහිපයක් දෙස බලමු.

මන්දගාමී යතුරු ලීට්කෝඩ් විසඳුම

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

පැහැදිලි කිරීම: සෑම යතුරක්ම ගතවන කාලය 9, 20, 20, 1. මෙම මුදා හැරීමේ වේලාවන් පිළිවෙලින් c, b, c සහ d යතුරු සඳහා වේ. B සහ c යතුරු සඳහා මුදා හැරීමේ වේලාවන් සමාන බැවින්. ශබ්දකෝෂ විද්‍යාත්මකව විශාලතම යතුර අපි නැවත ලබා දෙන්නෙමු.

මන්දගාමී යතුරු ලීට්කෝඩ් විසඳුම සඳහා ප්‍රවේශය

මන්දගාමී යතුරු ලීට්කෝඩ් විසඳුම පිළිබඳ ගැටළුව දැනටමත් ඉහත විස්තර කර ඇත. කෙටියෙන් කිවහොත්, ක්‍රියාත්මක කිරීමට දීර් long තම වර්ගය ගන්නා යතුර සොයා ගැනීමට ගැටළුව අපෙන් ඉල්ලා ඇත. එසේ නම්, යතුරු දෙකක් හෝ වැඩි ගණනක් ක්‍රියාත්මක කිරීමට එකම කාලයක් ගතවේ. එවිට අපට ශබ්දකෝෂ විද්‍යාත්මකව විශාලතම යතුර ආපසු ලබා දිය යුතුය. ගැටළුව විසඳීම සඳහා, අපි එබූ යතුරු හරහා ගමන් කර එක් එක් යතුරු සඳහා මුදා හැරීමේ කාලය තක්සේරු කරමු. පළමු යතුර සඳහා එය releaseTime [0] ට සමාන වන අතර පසුව එය releaseTime [i] - releaseTime [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), ගැටලුව විසඳීම සඳහා අප භාවිතා කළේ අතිරේක විචල්‍යයන් දෙකක් පමණි.