ඩෙකොම්ප්‍රස් ධාවන-දිග සංකේතාත්මක ලැයිස්තුව ලීට්කෝඩ් විසඳුම


දුෂ්කරතා මට්ටම පහසු
නිතර අසනු ලැබේ ඇමේසන් Apple ජංගම දුරකථන ගූගල්
අරා

Decompress Run-Length Encoded List Leetcode Solution හි ගැටලුව වන්නේ ඔබට ලබා දී ඇති බවයි අරාව හෝ අනුක්‍රමයක් අඩංගු දෛශිකය. අනුක්‍රමයට නිශ්චිත නිරූපණයක් ඇත. ආදාන අනුක්‍රමය වෙනත් අනුක්‍රමයකින් සෑදී ඇත. අපි එය තවත් අනුක්‍රමයක් මුල් අනුක්‍රමය ලෙස හඳුන්වමු. ආදාන අනුක්‍රමය නිර්මාණය කර ඇති පරිදි. මුල් අනුක්‍රමය සොයා ගැනීමට අපෙන් ඉල්ලා සිටී. අනුක්‍රමයෙහි ඇති සෑම අමුතු (ith) දර්ශකයක්ම මුල් අනුක්‍රමය තුළ පහත දැක්වෙන (i + 1) දර්ශකය පුනරාවර්තනය වන වාර ගණන නියෝජනය කරයි. එබැවින්, සෑම විටම විසඳුමට කිමිදීමට පෙර අපි උදාහරණ කිහිපයක් දෙස බලමු.

ඩෙකොම්ප්‍රස් ධාවන-දිග සංකේතාත්මක ලැයිස්තුව ලීට්කෝඩ් විසඳුම

nums = [1,2,3,4]
[2,4,4,4]

පැහැදිලි කිරීම: ප්‍රතිදානය නිවැරදි දැයි තහවුරු කර ගනිමු. 2 මුල් ප්‍රකාශයේ 1 වතාවක් පුනරාවර්තනය වේ. එබැවින් ආදාන අනුක්‍රමය තුළ එය 1, 2 විය යුතුය. පසුව 4 වතාවක් 3 වතාවක් පුනරාවර්තනය වේ, එය ආදාන අනුක්‍රමයෙහි ද දැක්වේ. එබැවින්, ප්‍රතිදානය නිවැරදි බව මෙයින් සනාථ වේ.

nums = [1,1,2,3]
[1,3,3]

පැහැදිලි කිරීම: නැවතත් අපි ප්‍රතිදානය සත්‍යාපනය කළහොත්. 1 ට තනි පිටපතක් ඇති අතර 3 ක් දෙවරක් පුනරාවර්තනය වේ. නැවත වරක් ප්‍රතිදානය නිවැරදි ය.

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

Decompress Run-Length Encoded List Leetcode Solution යනු ගැටළුවකි. විවිධ සමාගම් විසින් පවත්වනු ලබන කේතීකරණ වට කිහිපයකින් නිතර අසනු ලැබේ. මුල් අනුක්‍රමය ගබඩා කිරීම සඳහා නව අරාවක් නිර්මාණය කළ යුතු බැවින් ප්‍රවේශය ඉතා සරල ය. අපි හුදෙක් අරාව හෝ දෛශිකය භාවිතා කර පිටුපස මූලද්‍රව්‍ය එකතු කරමින් සිටිමු.

එක් එක් පුනරාවර්තනයෙන් පසුව ඒකක 2 ක් පනින a for loop එකක් අපට ධාවනය කළ හැකිය. මෙයින් තහවුරු වන්නේ අප ගනුදෙනු කරන්නේ (සංඛ්‍යාතය, අගය) යුගල සමඟ පමණක් බවයි. දැන් නැවතත් ලූප් සඳහා කැදැල්ලකින්, අපි ith දර්ශකයේ මූලද්‍රව්‍යය දෛශිකයට එකතු කරමු. දී ඇති ආදාන අනුපිළිවෙලෙහි i + 1 වන දර්ශකයේ මූලද්‍රව්‍යය අනුව අපි කූඩුව ලූප් සඳහා ධාවනය කරමු.

ඩෙකොම්ප්‍රස් ධාවන-දිග සංකේතාත්මක ලැයිස්තු ලීට්කෝඩ් විසඳුම සඳහා කේතය

සී ++ කේතය

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

vector<int> decompressRLElist(vector<int>& nums) {
    vector<int> tmp;
    for(int i=0;i<nums.size();i+=2){
        for(int j=0;j<nums[i];j++)
            tmp.push_back(nums[i+1]);
    }
    return tmp;
}

int main(){
    vector<int> input = {1,2,3,4};
    vector<int> output = decompressRLElist(input);
    for(auto x: output)cout<<x<<" ";
}
2 4 4 4

ජාවා කේතය

import java.util.*;
import java.lang.*;
import java.io.*;

class Main
{
  public static int[] decompressRLElist(int[] nums) {
        int size = 0, k = 0;
        for(int i=0;i<nums.length;i+=2)
            size += nums[i];
        int[] tmp = new int[size];
        for(int i=0;i<nums.length;i+=2){
            for(int j=0;j<nums[i];j++)
                tmp[k++] = nums[i+1];
        }
        return tmp;
    }
    
  public static void main (String[] args) throws java.lang.Exception{
    int[] input = {1,2,3,4};
      int[] output = decompressRLElist(input);
      for(Integer x: output)System.out.print(x+" ");
  }
}
2 4 4 4

සංකීර්ණ විශ්ලේෂණය

කාල සංකීර්ණත්වය

මත), මෙහි N යනු නිමැවුමේ දිග වේ. මෙහිදී කාල සංකීර්ණත්වය ආදානය මත රඳා නොපවතී. ආදානය වෙනුවට, කාල සංකීර්ණත්වය රඳා පවතින්නේ ප්‍රතිදානය හෝ ලබාගත් ප්‍රති result ලය මත ය.

අභ්‍යවකාශ සංකීර්ණතාව

මත), මෙහි N යනු නිමැවුමේ දිග වේ. අපි ප්‍රතිදානය ගබඩා කරන බැවින් අපි එය ආපසු ලබා දෙන්නෙමු. අවකාශය ද එහි වාසය කරයි.