ಆಲ್ಫಾಬೆಟ್‌ನಿಂದ ಇಂಟಿಜರ್ ಮ್ಯಾಪಿಂಗ್ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರಕ್ಕೆ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಡೀಕ್ರಿಪ್ಟ್ ಮಾಡಿ


ತೊಂದರೆ ಮಟ್ಟ ಸುಲಭ
ಆಗಾಗ್ಗೆ ಕೇಳಲಾಗುತ್ತದೆ ಕ್ವಿಪ್ ಸೇಲ್ಸ್ಫೋರ್ಸ್
ಸ್ಟ್ರಿಂಗ್

ಸಮಸ್ಯೆ ಹೇಳಿಕೆ

ಈ ಸಮಸ್ಯೆಯಲ್ಲಿ, ನಮಗೆ ಅಂಕೆಗಳು (0-9) ಮತ್ತು '#' ಹೊಂದಿರುವ ಸ್ಟ್ರಿಂಗ್ ನೀಡಲಾಗಿದೆ. ಕೆಳಗಿನ ಮ್ಯಾಪಿಂಗ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ನಾವು ಈ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಸಣ್ಣ ಇಂಗ್ಲಿಷ್ ಅಕ್ಷರಗಳ ಸ್ಟ್ರಿಂಗ್ ಆಗಿ ಪರಿವರ್ತಿಸಬೇಕು.

ಆಲ್ಫಾಬೆಟ್‌ನಿಂದ ಇಂಟಿಜರ್ ಮ್ಯಾಪಿಂಗ್ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರಕ್ಕೆ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಡೀಕ್ರಿಪ್ಟ್ ಮಾಡಿ

ಉದಾಹರಣೆ

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

ವಿವರಣೆ:

“10 #” -> “ಜೆ”, “11 #” -> “ಕೆ”, “1” -> “ಎ”, “2” -> “ಬಿ”.

s = "1326#"
"acz"

ವಿವರಣೆ:

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

ಅಪ್ರೋಚ್

ನಾವು '#' ಬಗ್ಗೆ ಕಾಳಜಿ ವಹಿಸಬೇಕಾಗಿದೆ ಎಂದು ನಾವು ನೋಡಬಹುದು. ಕೌಂಟರ್ ಬಳಸಿ ನಾನು ಕೊಟ್ಟಿರುವ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಎಡದಿಂದ ಬಲಕ್ಕೆ ಸಾಗಿಸಿದಾಗ (ನಾನು ಅವಕಾಶ ಮಾಡಿಕೊಡಿ), ನಂತರ, ಪ್ರತಿ ಸೂಚ್ಯಂಕಕ್ಕೆ ನಾನು (0 <= i <= n-3), ಮುಂದಿನ ಸೂಚ್ಯಂಕದ ಪಕ್ಕದಲ್ಲಿರುವ ಅಕ್ಷರ i ನಿಂದ ಇದೆಯೇ ಎಂದು ನಾವು ಪರಿಶೀಲಿಸಬೇಕು ಅಂದರೆ ಸೂಚ್ಯಂಕ i + 2 ನಲ್ಲಿನ ಅಕ್ಷರ '#' ಆಗಿದೆ.

ಪ್ರತಿ i (0 ರಿಂದ n-3) ಗೆ, ಸೂಚ್ಯಂಕ i + 2 ನಲ್ಲಿನ ಅಕ್ಷರವು '#' ಆಗಿದ್ದರೆ ಈ ಸೂಚ್ಯಂಕ i ಅನ್ನು i + 1 ನೊಂದಿಗೆ ಸಂಯೋಜಿಸಿ ಮತ್ತು ಈ ಎರಡು ಅಂಕೆಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಅಕ್ಷರವನ್ನು ರೂಪಿಸಿ.
ಉದಾ. ಹೀಗೆ ನಾನು ಮತ್ತು ನಾನು + 12 ಸೂಚ್ಯಂಕಗಳಲ್ಲಿರುವ ಅಂಕೆಗಳನ್ನು ಸಂಯೋಜಿಸಿ ಅಂದರೆ 0 ಮತ್ತು 2 ಅಂಕೆಗಳನ್ನು ಸಂಯೋಜಿಸಿ, ಅವುಗಳನ್ನು “1” ಮಾಡಿ. ಈಗ 1 ಅನ್ನು ಅದರ ಅಕ್ಷರ ಮ್ಯಾಪಿಂಗ್‌ಗೆ ಅಂದರೆ “l” ಗೆ ಪರಿವರ್ತಿಸಿ ಮತ್ತು ಅದನ್ನು ಸೇರಿಸಿ ಸ್ಟ್ರಿಂಗ್‌ಬಿಲ್ಡರ್ sb.
ಸ್ಟ್ರಿಂಗ್ “12” ಅನ್ನು 'ಎಲ್' ಅಕ್ಷರಕ್ಕೆ ಪರಿವರ್ತಿಸಲು, ನಾವು ಪರಿವರ್ತಿಸುವ ಕಾರ್ಯವನ್ನು ರಚಿಸಿದ್ದೇವೆ, ಅದು ಸ್ಟ್ರಿಂಗ್ ಸ್ವರೂಪದಲ್ಲಿ ಸಂಖ್ಯೆಯನ್ನು ತೆಗೆದುಕೊಂಡು ಅದನ್ನು ಅನುಗುಣವಾದ ಅಕ್ಷರಕ್ಕೆ ಪರಿವರ್ತಿಸುತ್ತದೆ.
ಮತ್ತು ಸೂಚ್ಯಂಕ i + 2 ನಲ್ಲಿನ ಅಕ್ಷರವು '#' ಆಗಿಲ್ಲದಿದ್ದರೆ ನಾವು ಸೂಚ್ಯಂಕ i ನಲ್ಲಿನ ಅಕ್ಷರವನ್ನು ಸೂಚ್ಯಂಕ i + 1 ನಲ್ಲಿರುವ ಅಕ್ಷರದೊಂದಿಗೆ ಸಂಯೋಜಿಸಬಾರದು.

ಉದಾ. “123”, ನಾವು ಸೂಚ್ಯಂಕ i = 0 ನಿಂದ ನೋಡಿದರೆ, ಸೂಚ್ಯಂಕ i + 2 ಅಂದರೆ 2 ರ ಅಕ್ಷರವು '#' ಅಲ್ಲ, ಆದ್ದರಿಂದ ನಾವು ನಮ್ಮ ಉತ್ತರದಲ್ಲಿ “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) ಸಮಯವನ್ನು ತೆಗೆದುಕೊಳ್ಳಲಾಗುತ್ತದೆ.

ಬಾಹ್ಯಾಕಾಶ ಸಂಕೀರ್ಣತೆ 

ಒ (ಎನ್): ಸಿಪಿಪಿಯಲ್ಲಿ ಜಾವಾ ಮತ್ತು ಸ್ಟ್ರಿಂಗ್ ಸ್ಟ್ರೀಮ್‌ನ ಸಂದರ್ಭದಲ್ಲಿ ನಾವು ಸ್ಟ್ರಿಂಗ್ ಬಿಲ್ಡರ್ ಅನ್ನು ಬಳಸಿದ್ದೇವೆ. ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ ಉದ್ದವು ಇನ್ಪುಟ್ ಸ್ಟ್ರಿಂಗ್ ಉದ್ದಕ್ಕೆ ಸಮನಾಗಿರುತ್ತದೆ. ಹೀಗಾಗಿ, ಬಾಹ್ಯಾಕಾಶ ಸಂಕೀರ್ಣತೆಯು ಒ (ಎನ್) ಆಗಿದೆ.