ఆల్ఫాబెట్ నుండి ఇంటీజర్ మ్యాపింగ్ లీట్‌కోడ్ సొల్యూషన్‌కు స్ట్రింగ్‌ను డీక్రిప్ట్ చేయండి


కఠినత స్థాయి సులువు
తరచుగా అడుగుతుంది హాస్య ప్రసంగము అమ్మకాల బలం
స్ట్రింగ్

సమస్యల నివేదిక

ఈ సమస్యలో, మాకు అంకెలు (0-9) మరియు '#' ఉన్న స్ట్రింగ్ ఇవ్వబడుతుంది. కింది మ్యాపింగ్‌ను ఉపయోగించి మేము ఈ స్ట్రింగ్‌ను చిన్న ఆంగ్ల అక్షరాల స్ట్రింగ్‌గా మార్చాలి.

ఆల్ఫాబెట్ నుండి ఇంటీజర్ మ్యాపింగ్ లీట్‌కోడ్ సొల్యూషన్‌కు స్ట్రింగ్‌ను డీక్రిప్ట్ చేయండి

ఉదాహరణ

s = "10#11#12"
"jkab"

వివరణ:

“10 #” -> “j”, “11 #” -> “k”, “1” -> “a”, “2” -> “b”.

s = "1326#"
"acz"

వివరణ:

“1” -> “a”, “3” -> “c”, “26 #” -> “z”.

అప్రోచ్

మనం '#' గురించి ఆందోళన చెందాల్సిన అవసరం ఉందని మనం చూడవచ్చు. మేము ఇచ్చిన స్ట్రింగ్‌ను కౌంటర్ ఉపయోగించి ఎడమ నుండి కుడికి ప్రయాణిస్తున్నప్పుడు (లెట్ i), అప్పుడు, ప్రతి ఇండెక్స్ i (0 <= i <= n-3) కోసం, మనం తదుపరి ఇండెక్స్ పక్కన ఉన్న అక్షరం i నుండి అనగా ఇండెక్స్ i + 2 లోని అక్షరం '#'.

ప్రతి i (0 నుండి n-3) కోసం, సూచిక i + 2 లోని అక్షరం '#' అయితే, ఈ సూచిక i ని i + 1 తో కలిపి ఈ రెండు అంకెలను ఉపయోగించి అక్షరాన్ని ఏర్పరుస్తుంది.
ఉదా. “12 #”, మనం స్ట్రింగ్‌ను ఎడమ నుండి కుడికి దాటితే, i = 0 అయినప్పుడు i + 2 సూచికలోని అక్షరం '#' అని మనం చూస్తాము. ఈ విధంగా i మరియు i + 1 సూచికలలో ఉన్న అంకెలను కలపండి, అంటే 1 మరియు 2 అంకెలను మిళితం చేసి, వాటిని “12” గా చేయండి. ఇప్పుడు 12 ను దాని అక్షర మ్యాపింగ్‌కు మార్చండి, అంటే “l” మరియు దానిని చేర్చండి స్ట్రింగ్ బిల్డర్ sb.
స్ట్రింగ్ “12” ను 'l' అక్షరానికి మార్చడానికి, మేము కన్వర్ట్ ఫంక్షన్‌ను సృష్టించాము, ఇది స్ట్రింగ్ ఫార్మాట్‌లో ఒక సంఖ్యను తీసుకుంటుంది మరియు దానిని సంబంధిత అక్షరానికి మారుస్తుంది.
మరియు ఇండెక్స్ i + 2 లోని అక్షరం '#' కాకపోతే, మనం ఇండెక్స్ i వద్ద అక్షరాన్ని ఇండెక్స్ i + 1 వద్ద అక్షరాలతో మిళితం చేయకూడదు.

ఉదా.

ఇండెక్స్ n-2 మరియు n-1 లోని అక్షరాల కోసం, n-1 వద్ద చార్ ఇప్పటికే '#' గా ఉంటే, అప్పుడు మేము ఇండెక్స్ n-3 తర్వాత లూప్ నుండి బయటపడతాము, లేకపోతే రెండు అక్షరాలు n-2 మరియు n-1 విడిగా మ్యాప్ చేయాలి.

అమలు

ఆల్ఫాబెట్ నుండి ఇంటీజర్ మ్యాపింగ్ లీట్‌కోడ్ సొల్యూషన్ వరకు స్ట్రింగ్‌ను డీక్రిప్ట్ చేయడానికి సి ++ ప్రోగ్రామ్

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

char convert(string str){
    stringstream ss(str);
    int num;
    ss>>num;
    return num+96;
}

string freqAlphabets(string s) {
        stringstream ss;
        int i=0;
        while(i<s.length()-2){
            char ch;
            if(s[i+2]=='#'){
                ch=(char)convert(s.substr(i, 2) );
                i+=2;
            }else{
                ch=(char)convert(s.substr(i,1));
            }
            i++;
            ss<<ch;
        }
        while(i<s.length()){
            char ch=(char)convert(s.substr(i,1));
            ss<<ch;
            i++;
        }
        
        return ss.str();
    }

int main()
{
    cout << freqAlphabets("1326#") ;
}
acz

ఆల్ఫాబెట్ నుండి ఇంటీజర్ మ్యాపింగ్ లీట్‌కోడ్ సొల్యూషన్ వరకు స్ట్రింగ్‌ను డీక్రిప్ట్ చేయడానికి జావా ప్రోగ్రామ్

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

class Rextester
{  
    public static String freqAlphabets(String s) {
        StringBuilder sb=new StringBuilder();
        int i=0;
        while(i<s.length()-2){
            char ch;
            if(s.charAt(i+2)=='#'){
                ch=(char)convert(s.substring(i,i+2));
                i+=2;
            }else{
                ch=(char)convert(s.substring(i,i+1));
            }
            i++;
            sb.append(ch);
        }
        while(i<s.length()){
            char ch=(char)convert(s.substring(i,i+1));
            sb.append(ch);
            i++;
        }
        
        return sb.toString();
    }
    
    
    public static int convert(String str){
        int num=Integer.parseInt(str);
        return num+96;
    }

    public static void main(String args[])
    {
        System.out.println(freqAlphabets("10#11#12"));
    }
}
jkab

ఆల్ఫాబెట్ నుండి ఇంటీజర్ మ్యాపింగ్ లీట్‌కోడ్ సొల్యూషన్ వరకు డిక్రిప్ట్ స్ట్రింగ్ కోసం సంక్లిష్టత విశ్లేషణ

సమయం సంక్లిష్టత

పై): ఎందుకంటే మన ఇన్పుట్ స్ట్రింగ్ ను ఎడమ నుండి కుడికి సరళంగా ప్రయాణిస్తున్నందున O (n) సమయం తీసుకోబడుతుంది.

అంతరిక్ష సంక్లిష్టత 

పై): మేము cpp లో జావా మరియు స్ట్రింగ్ స్ట్రీమ్ విషయంలో స్ట్రింగ్ బిల్డర్‌ను ఉపయోగించాము. చెత్త సందర్భంలో పొడవు ఇన్పుట్ స్ట్రింగ్ పొడవు వలె ఉంటుంది. అందువల్ల, స్థల సంక్లిష్టత కూడా O (n).