ડીકમ્પ્રેસ રન-લંબાઈ એન્કોડેડ સૂચિ લીટકોડ સોલ્યુશન


મુશ્કેલી સ્તર સરળ
વારંવાર પૂછવામાં આવે છે એમેઝોન સફરજન Google
અરે

સમસ્યા ડિકોમ્પ્રેસને રન-લંબાઈ એન્કોડેડ સૂચિ લીટકોડ સોલ્યુશન જણાવે છે કે તમને એક આપવામાં આવ્યું છે એરે અથવા વેક્ટર જેમાં ક્રમ છે. અનુક્રમમાં કેટલીક વિશિષ્ટ રજૂઆત છે. ઇનપુટ ક્રમ બીજા ક્રમમાંથી રચાય છે. અમે તે બીજા ક્રમને મૂળ ક્રમ તરીકે કહીશું. જે મુજબ ઇનપુટ ક્રમ બનાવવામાં આવ્યો છે. અમને મૂળ ક્રમ શોધવા માટે કહેવામાં આવે છે. અનુક્રમમાં દરેક વિચિત્ર (આઈથ) અનુક્રમણિકા મૂળ અનુક્રમમાં નીચે આપેલા (i + 1th) પુનરાવર્તનની સંખ્યાને રજૂ કરે છે. તેથી, સોલ્યુશનમાં ડાઇવ કરતા પહેલા હંમેશાં થોડા ઉદાહરણો જોઈએ.

ડીકમ્પ્રેસ રન-લંબાઈ એન્કોડેડ સૂચિ લીટકોડ સોલ્યુશન

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 ને બે વાર પુનરાવર્તિત કરવામાં આવે છે. ફરી એકવાર આઉટપુટ યોગ્ય છે.

ડિકોમ્પ્રેસ રન-લંબાઈ એન્કોડેડ સૂચિ લીટકોડ સોલ્યુશન માટે અભિગમ

સમસ્યા ડિકોમ્પ્રેસને રન-લંબાઈ એન્કોડેડ સૂચિ લીટકોડ સોલ્યુશન એક પ્રમાણભૂત છે. અને વિવિધ કંપનીઓ દ્વારા હાથ ધરવામાં આવતા કેટલાક કોડિંગ રાઉન્ડમાં વારંવાર પૂછવામાં આવે છે. અભિગમ ખૂબ જ સરળ છે કારણ કે આપણે મૂળ ક્રમ સંગ્રહિત કરવા માટે નવી એરે બનાવવાની જરૂર છે. આપણે ફક્ત એરે અથવા વેક્ટરનો ઉપયોગ કરીએ છીએ અને પાછળના ભાગોમાં તત્વો ઉમેરવાનું ચાલુ રાખીએ છીએ.

આપણે લૂપ ચલાવી શકીએ છીએ જે દરેક પુનરાવૃત્તિ પછી 2 એકમોને કૂદી જાય છે. આ પુષ્ટિ કરે છે કે અમે ફક્ત (આવર્તન, મૂલ્ય) જોડીઓ સાથે વ્યવહાર કરીએ છીએ. હવે ફરીથી લૂપ માટેના નેસ્ટેડ સાથે, અમે વેથરમાં ઇથ ઇન્ડેક્સમાં તત્વ ઉમેરીએ છીએ. આપેલ ઇનપુટ અનુક્રમમાં 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

જટિલતા વિશ્લેષણ

સમય જટિલતા

ઓ (એન), જ્યાં એન આઉટપુટની લંબાઈ છે. અહીં સમય જટિલતા ઇનપુટ પર આધારિત નથી. ઇનપુટને બદલે, સમયની જટિલતા પ્રાપ્ત આઉટપુટ અથવા પરિણામ પર આધારિત છે.

અવકાશ જટિલતા

ઓ (એન), જ્યાં એન આઉટપુટની લંબાઈ છે. કારણ કે આપણે આઉટપુટ સંગ્રહ કરીએ છીએ કારણ કે આપણે તેને પરત કરી રહ્યા છીએ. જગ્યા પણ તેના કબજે છે.