डीकंप्रेस रन-लेंथ इनकोडेड लिस्ट लेकोडकोड सॉल्यूशन


कठिनाई स्तर आसान
में अक्सर पूछा वीरांगना सेब गूगल
ऐरे

समस्या 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 के लिए दृष्टिकोण

समस्या Decompress रन-लंबाई एन्कोडेड सूची Leetcode समाधान एक मानक एक है। और विभिन्न कंपनियों द्वारा आयोजित कई कोडिंग राउंड में अक्सर पूछा जाता है। दृष्टिकोण बहुत सरल है क्योंकि हमें मूल अनुक्रम को संग्रहीत करने के लिए एक नई सरणी बनाने की आवश्यकता है। हम या तो सरणी या एक वेक्टर का उपयोग करते हैं और पीछे के तत्वों को जोड़ते रहते हैं।

हम लूप के लिए चला सकते हैं जो प्रत्येक पुनरावृत्ति के बाद 2 इकाइयों को कूदता है। यह पुष्टि करता है कि हम केवल (आवृत्ति, मूल्य) जोड़े के साथ सौदा करते हैं। अब फिर से लूप के लिए नेस्टेड के साथ, हम तत्व को आइथ इंडेक्स में वेक्टर में जोड़ते हैं। हम दिए गए इनपुट अनुक्रम में i + 1 वें सूचकांक पर तत्व के अनुसार लूप के लिए नेस्टेड चलाते हैं।

कोड के लिए डीकंप्रेस रन-लंबाई एन्कोडेड लिस्टकोड समाधान

C ++ कोड

#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 आउटपुट की लंबाई है। यहां समय जटिलता इनपुट पर निर्भर नहीं करती है। इनपुट के बजाय, समय जटिलता प्राप्त आउटपुट या परिणाम पर निर्भर है।

अंतरिक्ष जटिलता

पर), जहां N आउटपुट की लंबाई है। चूंकि हम आउटपुट को स्टोर करते हैं क्योंकि हम इसे वापस कर रहे हैं। अंतरिक्ष भी इसके कब्जे में है।