లైసెన్స్ కీ ఫార్మాటింగ్ లీట్‌కోడ్ సొల్యూషన్


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

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

“లైసెన్స్ కీ ఫార్మాటింగ్” సమస్యలో, ఇన్పుట్ a ని కలిగి ఉంటుంది స్ట్రింగ్ అక్షరాల, లైసెన్స్ కీని సూచిస్తుంది. ప్రారంభంలో, స్ట్రింగ్‌ను N + 1 సమూహాలుగా (పదాలు) మధ్యలో N డాష్‌లు వేరు చేస్తాయి. మనకు పూర్ణాంక K కూడా ఇవ్వబడింది, మరియు ప్రతి సమూహంలో ఖచ్చితంగా K అక్షరాలను కలిగి ఉండే స్ట్రింగ్‌ను ఫార్మాట్ చేయడమే లక్ష్యం, మొదటిది మినహా, K కంటే తక్కువ అక్షరాలకు అనుమతించబడుతుంది. అంతేకాకుండా, సమూహాలను '- '(డాష్) మరియు పెద్ద అక్షరాలు మాత్రమే ఉన్నాయి.

ఉదాహరణ

S = "5F3Z-2e-9-w", K = 4
5F3Z-2E9W
S = "2-5g-3-J", K = 2
2-5G-3J

అప్రోచ్

స్ట్రింగ్ s (ఇన్పుట్) లో వెనుకకు మళ్ళించేటప్పుడు మనం క్రొత్త స్ట్రింగ్‌ను సృష్టించాలి అనేది సహజమైనది. ఇది చాలా ముఖ్యం ఎందుకంటే మొదటి గుంపు తప్ప, మిగతా అన్ని సమూహాలలో వాటిలో ఖచ్చితంగా 'k' అక్షరాలు ఉండాలి. మేము స్ట్రింగ్ s లో తిరిగి మళ్ళిస్తే, మనం a ని నిర్వహించవచ్చు కౌంటర్ ఇది సమూహంలో జోడించిన అక్షరాల సంఖ్యను లెక్కిస్తుంది. ఇది ఏ క్షణంలోనైనా 'k' కు సమానంగా మారితే, మేము దానిని తిరిగి సున్నాకి రీసెట్ చేయవచ్చు. ఈ విధంగా మేము క్రొత్త స్ట్రింగ్‌లోని మూలకాలను జోడిస్తూనే ఉంటాము మరియు దానిని తిరిగి ఇచ్చే ముందు, ఆర్డర్‌ను తిరిగి పొందడం కోసం దాన్ని రివర్స్ చేస్తాము.

లైసెన్స్ కీ ఫార్మాటింగ్ లీట్‌కోడ్ సొల్యూషన్ అమలు

సి ++ ప్రోగ్రామ్

#include <bits/stdc++.h>

using namespace std;

string licenseKeyFormatting(string s , int k) {
    string ans;
    int cnt = 0 , n = s.size();

    for(int i = n - 1 ; i >= 0 ; i--) {
        if(s[i] != '-') {
            if(cnt == k) {
                ans += '-';
                cnt = 0;
            }
            cnt++;
            if(s[i] >= 'a' && s[i] <= 'z') {
                s[i] += 'A' - 'a';
            }
            ans += s[i];
        }
    }

    reverse(ans.begin() , ans.end());
    return ans;
}

int main() {
    string s = "5F3Z-2e-9-w";
    int K = 4;
    cout << licenseKeyFormatting(s, K) << endl;
    return 0;
}

జావా ప్రోగ్రామ్

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

class license_key {
    public static void main(String args[]) {
        String s = "5F3Z-2e-9-w";
        int K = 4;
        System.out.println(licenseKeyFormatting(s , K));
    }

    public static String licenseKeyFormatting(String s , int k) {
        StringBuilder ans = new StringBuilder();
        int cnt = 0 , n = s.length();

        char c;
        for(int i = n - 1 ; i >= 0 ; i--) {
            c = s.charAt(i);
            if(c != '-') {
                if(cnt == k) {
                    ans.append('-');
                    cnt = 0;
                }
                cnt++;
                if(c >= 'a' && c <= 'z') {
                    c += 'A' - 'a';
                }
                ans.append(c);
            }
        }
        return ans.reverse().toString();
    }
}
5F3Z-2E9W

లైసెన్స్ కీ ఫార్మాటింగ్ యొక్క సంక్లిష్టత విశ్లేషణ లీట్‌కోడ్ పరిష్కారం

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

O (N), N = స్ట్రింగ్ యొక్క పొడవు. మేము స్ట్రింగ్‌ను ఒకసారి మళ్ళించినప్పుడు ప్రోగ్రామ్ సరళంగా ఉంటుంది.

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

O (1), మేము స్థిరమైన మెమరీ స్థలాన్ని ఉపయోగిస్తున్నప్పుడు.