परवाना की स्वरूपन लीटकोड सोल्यूशन


अडचण पातळी सोपे
वारंवार विचारले कॅपिटल वन Google
अक्षरमाळा स्ट्रिंगबिल्डर

समस्या विधान

“परवाना की स्वरूपन” या समस्येमध्ये इनपुटमध्ये अ स्ट्रिंग अक्षरे, परवाना की प्रतिनिधित्व. सुरुवातीला, स्ट्रिंगला N + 1 गटांमध्ये विभाजित केले गेले (शब्द) त्या दरम्यान एन डॅशद्वारे. आम्हाला एक पूर्णांक के देखील दिले गेले आहे, आणि प्रत्येक गटात के-वर्णांपेक्षा कमी वर्णांची अनुमती असलेल्या पहिल्या गट वगळता प्रत्येक गटात तंतोतंत के अक्षरे असलेली स्ट्रिंगचे स्वरुपण करणे हे आहे. शिवाय, गट '- ने विभक्त केले जाणे आवश्यक आहे. '(डॅश) आणि फक्त अपरकेस अक्षरे आहेत.

उदाहरण

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

दृष्टीकोन

हे अंतर्ज्ञानी आहे की स्ट्रिंग एस (इनपुट) मध्ये बॅकवर्ड करताना नवीन स्ट्रिंग तयार करावी. हे महत्वाचे आहे कारण आम्हाला माहित आहे की प्रथम गट वगळता इतर सर्व गटांमध्ये त्यामध्ये नक्कीच 'के' अक्षरे असणे आवश्यक आहे. जर आपण पुन्हा स्ट्रिंग s मध्ये पुनरावृत्ती केली तर आम्ही a ची देखभाल करू शकतो काउंटर जे गटात जोडलेल्या वर्णांची संख्या ठेवते. जर ते कोणत्याही क्षणी 'के' च्या बरोबरीचे झाले तर आपण ते पुन्हा शून्यावर परत आणू. अशा प्रकारे आम्ही नवीन स्ट्रिंगमध्ये घटक जोडत राहतो आणि परत करण्यापूर्वी आम्ही ऑर्डर परत मिळवण्यासाठी त्यास उलट करतो.

लाइसको की स्वरूपन लीटकोड सोल्यूशनची अंमलबजावणी

सी ++ प्रोग्राम

#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

परवाना की स्वरूपन लीटकोड सोल्यूशनचे जटिलता विश्लेषण

वेळ कॉम्प्लेक्सिटी

ओ (एन), एन = स्ट्रिंगची लांबी. जेव्हा आपण एकदा स्ट्रिंग पुनरावृत्ती केली तेव्हा हा प्रोग्रॅम रेषात्मक आहे.

स्पेस कॉम्प्लेक्सिटी 

ओ (1), जसे की आम्ही सतत मेमरी स्पेस वापरतो.